// biAdhocNs.ORIGO_COLUMN_CHAR = 'Ｓ：～ '; // 源字段分割符
// biAdhocNs.ORIGO_COMBINE_CHAR = 'Ｃ：＃ '; // 组合字段分割符
biAdhocNs.ORIGO_DEMENSION_CHAR = 'Ｄ：＠'; // 维度值分割符
biAdhocNs.conditionFilterObj = null; // 过滤条件面板当前对象

/**
 * 过滤条件组件 主程序
 */
biAdhocNs.ConditionFilter = Ext.extend( biAdhocNs.UXEditPanel, {
	currentSplitButtonID : '', 			// 当前被操作的splitbutton ID
	currentOprationEditContentID : '', 	// 当前操作的编辑框ID
	oprationChar : '', 					// 表达式操作符

	/**
	 * 过滤相关界面的tooltip初始化
	 */
	initFilterTooltip : function() {
		new Ext.ToolTip({ // 提示框
			id : 'show-condition-tooltip',
			anchor : 'top',
			dismissDelay : 2000,
			animate : true,
			hidden : true,
			autoDestroy : false,
			cls : 'splitbutton-zindex-h',
			items : [ {
				xtype : 'label',
				text : ''
			} ]
		}).hide();
		new Ext.Window({
			id : 'info-window',
			// anchor : 'right',
			autoHide : false,
			closable : true,
			hidden : true,
			draggable : true,
			width : 670,
			html : null,
			target : null,
			// show : biAdhocNs.ToolTipPlus.showAtCenter,
			cls : 'splitbutton-zindex',
			gird : null,
			items : [],
			listeners : {
				beforeshow : function(tip) { // 展示前清空里面所有对象
					var len = tip.items.length;
					if (len > 0) {
						tip.removeAll(true);
						tip.doLayout();
					}
				},
				show : function(tip) { // 展示时把对象加进去
					if (tip.grid != null) {
						tip.add(tip.grid);
						tip.doLayout();
					}
				}
			}
		}).hide();

		new Ext.ToolTip({ // 用户输入框
			id : 'show-use-input',
			anchor : 'left',
			autoHide : false,
			closable : true,
			hidden : true,
			width : 300,
			unbindTarget : biAdhocNs.ToolTipPlus.unbindTarget, // 此接口方法来源于showtree.js
			show : biAdhocNs.ToolTipPlus.showToolTip, // 此接口方法来源于showtree.js
			cls : 'splitbutton-zindex',
			html : '',
			listeners : {
				show : function() {
					// Ext.getCmp('show-more-operation-select').hide();//隐藏更多操作符选择框
				}
			}
		}).hide();

		// new biAdhocNs.UXToolTipWindow({ // 过滤条件编辑框
		new Ext.Window( {
			title : conditionfilter.edit,
			id : 'condition-edit',
			anchor : 'bottom',
			parentID : '',
			autoHide : false,
			closable : true,
			hidden : true,
			target : null,
			bodyStyle : 'padding:10px',
			html : null,
			width : 617,
			maxWidth : 617,
			draggable : { // 监控move
				insertProxy : false,
				onDrag : function(e) {
					// biAdhocNs.conditionFilterObj.closeAllTip();
				},
				endDrag : function(e) {
				}
			},
			// show :
			// biAdhocNs.ToolTipPlus.showAtCenter,
			items : [{
				xtype : 'panel',
				id : 'tip-condition-panel',
				width : 585,// 490
				// height : 265,
				autoScroll : false,
				buttonAlign : 'center',
				cls : 'panel-margin',
				items : [ {
					layout : 'column',
					border : false,
					defaults : {
						hideLabel : true
					},
					items : [{
						columnWidth : .37,
						xtype : 'fieldset',
						title : conditionfilter.leftColumn,
						id : 'left-fieldset',
						autoHeight : false,
						cls : ((Ext.isIE6) ? 'availableLot-filter-x-ie6'
								: 'availableLot-filter-x'),
						height : 224,
						listeners : {
							'afterrender' : function(fset) {
								biAdhocNs.conditionFilterObj.setContentEditable(
									fset,
									'fset-left-content-box',
									true); // 设置为编辑
							}
						}
					}, {
						columnWidth : .25,
						xtype : 'fieldset',
						title : conditionfilter.operator,
						id : 'center-op-char',
						cls : ((Ext.isIE6) ? 'availableLot-filter-x-ie6'
								: 'availableLot-filter-x'),
						autoHeight : false,
						height : 224,
						html : biAdhocNs.conditionFilterObj
								.getOpCharMultSelect()
					}, {
						columnWidth : .37,
						xtype : 'fieldset',
						title : conditionfilter.rightValue,
						id : 'right-fieldset',
						cls : ((Ext.isIE6) ? 'availableLot-filter-x-ie6'
								: 'availableLot-filter-x'),
						autoHeight : false,
						height : 224,
						items : [{
							xtype : "datefield",
							id : "datefieldId",
							format : "Ymd",
							fieldLabel : conditionfilter.date,
							width : 90,
							listeners : {
								select : function() {
									Ext.getDom('fset-right-content-box').innerText = this.value;
								}
							}
						}, {
							title : '',
							html : '<div id="dateTest" style="z-index=100"></div>'
						} ],
						listeners : {
							'beforerender' : function(fset) {
								var tip = Ext
										.getCmp('condition-edit'); // 获取展示tooltip对象
								var btn = Ext
										.getCmp(tip.parentID);
								var colTypeFlag = btn.attributes.colType;
								if (colTypeFlag == 3) {
									Ext.getCmp('datefieldId').format = 'Ymd';
									Ext.getCmp('datefieldId').show();
								} else if (colTypeFlag == 4) {
									Ext.getCmp('datefieldId').format = 'Ym';
									Ext.getCmp('datefieldId').show();
								} else {
									Ext.getCmp('datefieldId').hide();
								}
							},
							'afterrender' : function(fset) {
								var onclick = 'biAdhocNs.conditionFilterObj.showReferenceValue();';
								fset.header.createChild({
											tag : 'a',
											href : '#',
											onclick : onclick,
											html : conditionfilter.exampleValues
										});
								biAdhocNs.conditionFilterObj.setContentEditable(
												fset,
												'fset-right-content-box',
												true); // 设置为编辑
							}
						}
					}]
				}]
			}, {
				xtype : 'radiogroup',
				hideLabel : true,
				id : 'parameter-type-id',
				cls : 'condition-radio-group',
				items : [ {
					xtype : 'radio',
					checked : true,
					boxLabel : conditionfilter.valueParameter,
					name : "paramType", // 用于form提交时传送的参数名
					inputValue : "valuePara" // 提交时传送的参数值
				}, {
					xtype : 'radio',
					boxLabel : conditionfilter.formalParameter,
					name : "paramType",
					inputValue : "formalPara"
				} ]
			}, {
				xtype : 'button',
				text : conditionfilter.save,
				cls : 'condition-button-margin-x',
				iconCls : 'icon-accept',
				handler : function() {
					biAdhocNs.conditionFilterObj
							.saveDesign(); // 处理保存
				}
			}],
			listeners : {
				hide : function(tip) {
					try {
						// tip.unbindTarget(); //
						// 此接口方法来源于showtree.js
						Ext.getCmp('info-window')
								.hide(); // 隐藏维表或者编码表值弹出框
						Ext.getCmp('show-use-input')
								.hide(); // 隐藏输入框
						// Ext.getCmp('show-more-operation-select').hide();
						// // 隐藏操作符选择框

						Ext.getCmp(
								'info-function-window')
								.hide(); // 隐藏函数选择框
						// 清空函数输入框中的所有内容
						/*
						 * var tf =
						 * Ext.getCmp(biAdhocNs.conditionFilterObj.fxTextFieId);
						 * tf.setValue(''); tf.fxModels =
						 * [];
						 */
					} catch (e) {
					}
				},
				beforeshow : function(tip) {
					try {
						Ext.getDom('fset-left-content-box').innerHTML = '';
						Ext.getDom('fset-right-content-box').innerHTML = '';
					} catch (e) {
					}
				},
				show : function(tip) { // 还原对象
					tip.header.dom.style.cursor = 'move';
					var btn = Ext.getCmp(tip.parentID);
					var left_cb = Ext
							.getDom('fset-left-content-box');
					left_cb.onfocus = null;
					left_cb.innerHTML = biAdhocNs.conditionFilterObj
							.makeSpan(
									btn.attributes.tableCName
											+ '{'
											+ btn.text
											+ '}',
									'scolumn', btn.text);

					var right_cb = Ext
							.getDom('fset-right-content-box');
					// right_cb.innerHTML =
					// btn.saveRightHTML;
					right_cb.innerHTML = '';

					biAdhocNs.conditionFilterObj.currentSplitButtonID = tip.parentID; // 保存当前操作的buttonID
					// biAdhocNs.conditionFilterObj.restoreOP(btn.opChar);

					Ext.getCmp('datefieldId').hide();
					var tip = Ext
							.getCmp('condition-edit'); // 获取展示tooltip对象
					var btn = Ext.getCmp(tip.parentID);
					var colTypeFlag = btn.attributes.colType;
					if (colTypeFlag == 3) {
						Ext.getCmp('datefieldId').format = 'Ymd';
						Ext.getCmp('datefieldId')
								.show();
					}
					if (colTypeFlag == 4) {
						Ext.getCmp('datefieldId').format = 'Ym';
						Ext.getCmp('datefieldId')
								.show();
					}
				}
			}
		}).hide();

	},

	/**
	 * 用来接收返回的函数,在编辑框中生成span标签
	 * 
	 * @param tf
	 *            函数输入框对象
	 */
	confirmMakeFunction : function(tf) { // 点击函数‘v'时的回调函数
		try {
			var engfuntion = tf.getValue().trim();
			if (engfuntion.length > 0) {
				var tempParamMap = []; // 临时存储唯一的参数名，用以判断是否需要替换中文
				// 迭代函数
				for (var i = 0; i < tf.fxModels.length; i++) {
					// 迭代函数中参数
					for (var j = 0; j < tf.fxModels[i].params.length; j++) {
						var param = tf.fxModels[i].params[j];
						if (engfuntion.indexOf(param.name) != -1) {// 判断字段名
																	// 在函数编辑框中存在
							var tempflag = true;
							for (var k = 0; k < tempParamMap.length; k++) {
								if (tempParamMap[k].key == param.name) {// 本次编辑中是否已经存在这个参数
									tempflag = false;
									break;
								}
							}
							if (tempflag) {
								tempParamMap.push({
									key : param.name
								}); // 保存未替换的参数名

								// //替换英文成中文 替换字段名为 中文 span 标签
								engfuntion = engfuntion.replaceAll(param.name,
									biAdhocNs.conditionFilterObj.makeSpan(
																param.cname,
																'dcolumn',
																param.name));
							}
							// 记录字段信息和对应关系
							var btn = Ext
									.getCmp(biAdhocNs.conditionFilterObj.currentSplitButtonID);
							if (!biAdhocNs.conditionFilterObj
									.arrayHasSame(
											btn.columnGroup,
											param.name)) {// 保存字段对应信息
								btn.columnGroup
										.push({
											key : param.cname,
											value : param.name,
											nodeAttributes : param.nodeAttributes
										});
								// ******************王亿/陈壮伟提供以下的接口************************
								biAdhocNs.adhocJoinTablePanel
										.pushField(
												param.nodeAttributes.name,
												param.nodeAttributes.table); // 调用加入关联关系方法
							}
						}
					}
				}

				var html = biAdhocNs.conditionFilterObj
						.makeSpan(engfuntion, 'fun', '');
				biAdhocNs.conditionFilterObj
						.insertAtCaret(html);

				delete tempParamMap; // 删除临时唯一参数
			}
		} catch (e) {
		}

	},

	/**
	 * 用来接收添加的字段,在编辑框中生成SPAN标签
	 * 
	 * @param retColumns
	 *            字段数组
	 */
	confirmAddColumns : function(retColumns) {
		try {
			if (retColumns != null && retColumns.length > 0) {
				var nodeAttributes = null;
				var spanHtmlList = [];
				var btn = Ext
						.getCmp(biAdhocNs.conditionFilterObj.currentSplitButtonID);

				for (var i = 0; i < retColumns.length; i++) {
					// nodeAttributes =
					// retColumns[i].nodeAttributes;
					var nodeAttributes_tmp = retColumns[i].nodeAttributes;
					nodeAttributes = {
						asName : nodeAttributes_tmp.asName,
						cName : nodeAttributes_tmp.cName,
						colDesc : nodeAttributes_tmp.colDesc,
						colType : nodeAttributes_tmp.colType,
						configURL : nodeAttributes_tmp.configURL,
						dataType : nodeAttributes_tmp.dataType,
						defCondition : nodeAttributes_tmp.defCondition,
						id : nodeAttributes_tmp.id,
						isDelicate : nodeAttributes_tmp.isDelicate,
						isPrimaryKey : nodeAttributes_tmp.isPrimaryKey,
						joinType : nodeAttributes_tmp.joinType,
						leaf : nodeAttributes_tmp.leaf,
						name : nodeAttributes_tmp.name,
						objtype : nodeAttributes_tmp.objtype,
						pvId : nodeAttributes_tmp.pvId,
						relaTable : nodeAttributes_tmp.relaTable,
						showType : nodeAttributes_tmp.showType,
						table : {
							tableAreaCondition : nodeAttributes_tmp.table.tableAreaCondition,
							tableAsName : nodeAttributes_tmp.table.tableAsName,
							tableCName : nodeAttributes_tmp.table.tableCName,
							tableDefCondition : nodeAttributes_tmp.table.tableDefCondition,
							tableDesc : nodeAttributes_tmp.table.tableDesc,
							tableId : nodeAttributes_tmp.table.tableId,
							tableName : nodeAttributes_tmp.table.tableName,
							tablePartType : nodeAttributes_tmp.table.tablePartType
						},
						tableID : nodeAttributes_tmp.tableID,
						text : nodeAttributes_tmp.text,
						textColName : nodeAttributes_tmp.textColName,
						valueColName : nodeAttributes_tmp.valueColName
					};
					var cname = [
							nodeAttributes.table.tableCName,
							'{', nodeAttributes.cName, '}' ]
							.join(''); // 表中文名{字段名}
					var name = [
							nodeAttributes.table.tableAsName,
							'.', nodeAttributes.name ].join(''); // 别名.字段名
					var columnSpanHtml = biAdhocNs.conditionFilterObj
							.makeSpan(cname, 'dcolumn', name);
					spanHtmlList.push(columnSpanHtml);
					// 记录字段信息和对应关系
					if (!biAdhocNs.conditionFilterObj
							.arrayHasSame(btn.columnGroup, name)) {// 保存字段对应信息
						btn.columnGroup.push({
							key : cname,
							value : name,
							nodeAttributes : nodeAttributes
						});
						// ******************王亿/陈壮伟提供以下的接口************************
						biAdhocNs.adhocJoinTablePanel
								.pushField(nodeAttributes.name,
										nodeAttributes.table); // 调用加入关联关系方法
					}
				}
				var html = spanHtmlList.join('');
				biAdhocNs.conditionFilterObj
						.insertAtCaret(html);
			}
		} catch (e) {
		}
	},

	/**
	 * 过滤编辑保存
	 */
	saveDesign : function() { // 保存设置
		var cbleft = Ext.getDom('fset-left-content-box'); // 获取左编辑框对象
		var lefttext = cbleft.innerText.trim();
		var cbright = Ext.getDom('fset-right-content-box'); // 获取右编辑框对象
		var righttext = cbright.innerText.trim();
		var op = this.oprationChar; // 得到操作符
		op = op.trim().length == 0 ? '' : op; // 运行操作符两边有空格
		var tip = Ext.getCmp('condition-edit'); // 获取展示tooltip对象
		var btnId = tip.parentID;
		var btn = Ext.getCmp(btnId);
		var reOp;
		if (op.indexOf('AREA') != -1) {
			reOp = '';
		} else {
			reOp = op;
		}
		// var text = [lefttext, reOp, righttext].join('');
		if (lefttext == '' || op == '' || righttext == '') { // 没选择或者设置任何就不允许提交
			this.showAlterTipByMouseXY(conditionfilter.saveTip);
			return;
		}
		// text = this.replaceDimenKeyToText(text, btn);//
		// 替换维表的key（text_value） 变成 text
		// text =
		// text.replaceAll(biAdhocNs.ORIGO_DEMENSION_CHAR, '');
		// // 维度使用 ，对旧案例兼容
		var text = [ btn.attributes.cName, reOp, righttext ]
				.join('');
		btn.saveLeftHTML = cbleft.innerHTML;
		btn.saveRightHTML = cbright.innerHTML; // 保存设计的html
		if (op.indexOf('AREA') != -1) {
			btn.opChar = ''; // 保存设计的操作符
		} else {
			btn.opChar = op; // 保存设计的操作符
		}
		if (op.indexOf('IN') != -1) { // 有in的操作，就每4个值换行
			var ts = text.split(',');
			var len = ts.length;
			if (len > 4) { // 有选择4个值以上的
				text = [ ts[0], '......', ts[len - 1] ]
						.join('');
			}
		}
		btn.parameterType = Ext.getCmp('parameter-type-id')
				.getValue().inputValue;
		btn.atext = [ btn.attributes.name, reOp, righttext ]
				.join('');
		btn.avalue = righttext;
		btn.setText(text); // 改变展现的文字
		// this.refreshBtnTName(btn,
		// 'saveDesign');//设置节点text内容表名显示
		Ext.getCmp('datefieldId').hide();
		tip.hide();
	},

	/**
	 * 关闭所有过滤编辑相关的tooltip
	 */
	closeAllTip : function() { // 关闭相关的tooltip
		try {
			Ext.getCmp('info-window').hide();
			Ext.getCmp('show-use-input').hide();
			// Ext.getCmp('show-more-operation-select').hide();
			// Ext.getCmp('info-function-window').hide();

			// 清空函数输入框中的所有内容
			/*
			 * var tf = Ext.getCmp(this.fxTextFieId);
			 * tf.setValue(''); tf.fxModels = [];
			 */
		} catch (e) {
		}
	},

	/**
	 * 在lf对象中增加可编辑的span标签
	 * 
	 * @param lf
	 *            父对象
	 * @param cid
	 *            span的id
	 * @param editable
	 *            是否可编辑 boolean
	 */
	setContentEditable : function(lf, cid, editable) { // 将某个对象设置为可编辑状态
		var dom = lf.body.dom;
		var height = parseInt(dom.style.height);
		var width = height;
		var clicks = [
				'biAdhocNs.conditionFilterObj.spanOnClick( \'',
				cid, '\');' ].join('');
		dom.innerHTML = [ '<SPAN id=', cid,
				' class="dom-scrollbar-show" style="width: ',
				width, '; height: ', height,
				'" contentEditable="', editable, '" onclick="',
				clicks, '" onfocus="', clicks, '" onkeyup="',
				clicks, '"></SPAN>' ].join('');
	},

	setParamType : function(paramType) {
		var tip = Ext.getCmp('condition-edit'); // 获取展示tooltip对象
		var btnId = tip.parentID;
		var btn = Ext.getCmp(btnId);
		btn.parameterType = paramType;
	},

	/**
	 * SPAN编辑框的点击事件防范
	 * 
	 * @param cid
	 *            span对象id
	 */
	spanOnClick : function(cid) {
		this.currentOprationEditContentID = cid;
		this.storeCaret(Ext.getDom(cid));
		if (Ext.getCmp('current-editor-combo'))
			Ext.getCmp('current-editor-combo').setValue(
					cid.indexOf('left') != -1 ? conditionfilter.left : conditionfilter.right);
	},

	/**
	 * 设置参考值为所有项选择，且设置操作符为LIKE，右项值为'%'
	 */
	doSelectAll : function() {
		biAdhocNs.MultSelect.clickSelectIndex('multselect', 5);
		this.insertAtCaret(' \'%\' ');
		this.oprationChar = ' LIKE '; // 保存当前选择的操作符
	},

	/**
	 * 在当前光标处插入值
	 * 
	 * @param text
	 *            需要插入的内容
	 */
	insertAtCaret : function(text) { // 在当前光标处插入
		try {
			/*
			 * var textel =
			 * Ext.getDom(this.currentOprationEditContentID);
			 * var caretPos = textel.caretPos;
			 * caretPos.pasteHTML(caretPos.text.charAt(caretPos.text.length -
			 * 1) == ' ' ? text + ' ' : text);
			 */
			var textel = Ext
					.getDom(this.currentOprationEditContentID);
			textel.innerText = text;
		} catch (e) {
		}
	},

	/**
	 * 替换当前光标所在编辑框的内容
	 * 
	 * @param {}
	 *            text 新的内容
	 */
	replaceAtCaret : function(text) {
		try {
			var textel = Ext
					.getDom(this.currentOprationEditContentID);
			if (textel)
				textel.innerHTML = text;
		} catch (e) {
		}
	},

	/**
	 * 保存光标当前位置
	 * 
	 * @param textel
	 *            保存光标的对象
	 */
	storeCaret : function(textel) { // 保存光标当前位置
		try {
			textel.caretPos = textel.document.selection
					.createRange().duplicate();
		} catch (e) {
		}
	},

	/**
	 * 重构条件输出Panel的Drop事件,本接口给adhocquery.js调用
	 */
	/*
	 * listeners : { // 重构条件输出Panel的Drop事件,本接口给adhocquery.js调用
	 * afterrender : function(panel) {
	 * 
	 * var panelDropTargetEl = panel.body.dom; var
	 * panelDropTarget = new
	 * Ext.dd.DropTarget(panelDropTargetEl, { id :
	 * 'panel-condition-target', ddGroup : 'treeDDGroup', //
	 * 这个与tree设置的要一致 notifyEnter : function(ddSource, e, data) {
	 * panel.body.stopFx(); panel.body.highlight(); return
	 * (true); }, notifyDrop : function(ddSource, e, data) { //
	 * 处理拖拽事件 var attributes = data.node.attributes;
	 * 
	 * var plusComp = null; if (panel.items.getCount() > 0) { //
	 * 至少有一个以上的才能建立and/or关系 plusComp =
	 * panel.add(panel.generalOperComp()); } var comp =
	 * panel.addFilterComp(panel, attributes); comp.plusComp =
	 * plusComp;
	 *  //
	 * ******************王亿/陈壮伟提供以下的接口************************
	 * biAdhocNs.adhocJoinTablePanel.pushField(attributes.name,
	 * attributes.table); // 调用加入关联关系方法
	 * 
	 * panel.refreshBtnTName(comp,'dropObject');
	 * //设置节点text内容表名显示 //加入时自动弹出编辑框
	 * panel.filterConditionEdit(comp.id);
	 * 
	 * return (true); } }); } },
	 */

	/**
	 * 内部拖拽事件
	 * 
	 * @param {}
	 *            data
	 * @return {Boolean}
	 */
	doOnNotifyDrop : function(data) {
		var nodeData = data.node.getRawNodeData();
		var attributes = data.node.attributes;

		// 添加到容器
		this.insertToPanel(this, attributes);

		return true;
	},
	/**
	 * 插入到过滤条件panel中
	 * 
	 * @param {}
	 *            attributes 属性
	 */
	insertToPanel : function(panel, attributes) {
		var plusComp = null;
		if (panel.items.getCount() > 0) { // 至少有一个以上的才能建立and/or关系
			plusComp = panel.add(panel.generalOperComp());
		}
		var comp = panel.addFilterComp(panel, attributes);
		comp.plusComp = plusComp;

		// ******************王亿/陈壮伟提供以下的接口************************
		biAdhocNs.adhocJoinTablePanel.pushField(
				attributes.name, attributes.table); // 调用加入关联关系方法

		panel.refreshBtnTName(comp, 'dropObject'); // 设置节点text内容表名显示
		// 加入时自动弹出编辑框
		panel.filterConditionEdit(comp.id);
	},
	/**
	 * 拖拽字段到过滤面板时的程序入口
	 * 
	 * @param panel
	 *            主界面过滤面板
	 * @param attributes
	 *            拖入进来的字段对象attributes属性
	 */
	addFilterComp : function(panel, attributes) { // 程序入口，拖拽使用
		var parameterType = 'valueParam';
		var atext = [ attributes.tableCName, '{',
				attributes.cName, '}' ].join('');
		var tableAndColumn = [ attributes.tableName, '.',
				attributes.name ].join(''); // 别名+字段名
		var text = attributes.cName;
		var defc = attributes.defCondition; // 处理默认条件预处理
		var rightchar = '', leftchar = '';
		var opchar = '=';
		if (defc != null && defc.trim() != '') { // 字段带有默认条件,例如默认条件格式为：>|200
													// (操作符|值)
			var fefcs = defc.split('|');
			if (this.isInLikeBetweenOp(fefcs[0].toUpperCase())) // 处理like或者bettwen操作符
				opchar = [ ' ', fefcs[0].toUpperCase(), ' ' ]
						.join('');
			else
				opchar = fefcs[0].toUpperCase();
			rightchar = fefcs[1];
			text = [ atext, opchar, rightchar ].join('');
			leftchar = this.makeSpan(atext, 'scolumn',
					tableAndColumn);
		}

		var comp = panel.add({ // 加入对象
			compType : 'label', // 指定类型为2 (entity)
			plusComp : null,
			xtype : 'splitbutton',
			text : text,
			atext : atext,
			avalue : tableAndColumn,
			parameterType : parameterType,
			showTableText : text,
			hiddenTableText : '',
			scale : 'large',
			iconAlign : 'right',
			arrowAlign : 'bottom',
			cls : 'availableLot-filter-x',
			split : true,
			autoWidth : true,
			attributes : attributes, // 保存整个tree节点，方便取得节点的其他值。
			saveLeftHTML : leftchar,
			saveRightHTML : rightchar, // 保存一段HTML(右)。
			opChar : opchar, // 保存一个操作符
			dimensionGroup : [], // 保存用户所选到的维度的值,[{key:'',value:''}]结构形式保存数据。
			columnGroup : [],// 保存用户选到的字段
			template : this.splitButtonTemplate, // 改变默认的css
			menu : {
				items : [
					{
						text : conditionfilter.del,
						iconCls : 'delete',
						panelTargetID : panel.id,
						handler : function(item) {
							biAdhocNs.conditionFilterObj
									.filterConditionDelete(item); // 过滤条件删除
						}
					},
					{
						text : conditionfilter.edit,
						iconCls : 'collect',
						handler : function(item) {
							var btnId = item.parentMenu.ownerCt.id;
							biAdhocNs.conditionFilterObj
									.filterConditionEdit(btnId); // 过滤条件编辑
						}
					},
					{
						text : conditionfilter.insertBrackets,
						iconCls : 'insertlabel2',
						panelTargetID : panel.id,
						handler : function(item) {
							var panel = Ext
									.getCmp(item.panelTargetID);
							var label = Ext
									.getCmp(item.parentMenu.ownerCt.id);
							var index = panel.items
									.indexOf(label);
							panel.insert(index,
											panel.generalParenthesisComp('('));
							panel.insert(index + 2,
											panel.generalParenthesisComp(')'));

							panel.doLayout();
						}
					},
					{
						text : conditionfilter.copyToOutputArea,
						iconCls : 'copy',
						handler : function(item) {
							var btnId = item.parentMenu.ownerCt.id;
							biAdhocNs.conditionFilterObj.copyToOutput(btnId);
						}
					},
					{
						text : conditionfilter.moveToOutputArea,
						iconCls : 'move',
						panelTargetID : panel.id,
						handler : function(item) {
							var btnId = item.parentMenu.ownerCt.id;
							// 复制
							biAdhocNs.conditionFilterObj.copyToOutput(btnId);
							// 删除
							biAdhocNs.conditionFilterObj.filterConditionDelete(item);
						}
					} ]
				}
			});
		panel.doLayout(); // 渲染
		return comp;
	},

	/**
	 * 过滤对象克隆
	 * 
	 * @param comp
	 *            过滤条件对象
	 */
	cloneComponent : function(comp) {
		return comp.cloneConfig({
			text : comp.text,
			attributes : comp.attributes,
			saveLeftHTML : comp.saveLeftHTML,
			saveRightHTML : comp.saveRightHTML,
			opChar : comp.opChar,
			dimensionGroup : comp.dimensionGroup,
			columnGroup : comp.columnGroup,
			showTableText : comp.showTableText,
			hiddenTableText : comp.hiddenTableText,
			parameterType : comp.parameterType
		});
	},

	/**
	 * 生成逻辑连接符号
	 * 
	 * @param text
	 *            连接符
	 */
	generalOperComp : function(text) {
		text = text || 'AND';
		return {
			xtype : 'splitbutton',
			text : text,
			scale : 'large',
			iconAlign : 'right',
			arrowAlign : 'bottom',
			cls : 'availableLot-filter-x',
			split : true,
			autoWidth : true,
			compType : 'oper', // 指定类型为1 (OP)
			menu : {
				items : [
					{
						text : 'AND',
						iconCls : 'icon-tag',
						handler : function(item) {
							var btn = Ext
									.getCmp(item.parentMenu.ownerCt.id);
							btn.setText('AND');
						}
					},
					{
						text : 'OR',
						iconCls : 'icon-tag',
						handler : function(item) {
							var btn = Ext
									.getCmp(item.parentMenu.ownerCt.id);
							btn.setText('OR');
						}
					} 
				]
			}
		};
	},

	/**
	 * 删除过滤条件
	 * 
	 * @param item
	 *            过滤子选项
	 */
	filterConditionDelete : function(item) { // 过滤条件删除
		var btnId = item.parentMenu.ownerCt.id;
		var btn = Ext.getCmp(btnId); // 获取splitbutton对象
		var panel = Ext.getCmp(item.panelTargetID); // 获取panel对象
		var atts = btn.attributes;
		// ******************王亿/陈壮伟提供以下的的接口************************
		biAdhocNs.adhocJoinTablePanel.removeField(atts.name,
				atts.table.tableName); // 调用删除关联关系方法

		// 删除时删除其他字段关联
		var columns = btn.columnGroup;
		for (var i = 0; i < columns.length; i++) {
			// ******************王亿/陈壮伟提供以下的接口************************
			biAdhocNs.adhocJoinTablePanel.removeField(
					columns[i].nodeAttributes.name,
					columns[i].nodeAttributes.table.tableName); // 调用删除关联关系方法
		}

		// 将括号移到最前面
		panel.moveParenthesisToFront(btn);
		// 物理上删除选中的splitbutton
		panel.removeLabel(btn);
		panel.doLayout();
	},

	/**
	 * 复制到输出条件
	 * 
	 * @param {}
	 *            btnId
	 */
	copyToOutput : function(btnId) {
		var btn = Ext.getCmp(btnId);
		var attr = btn.attributes;
		var targetPanel = biAdhocNs.outputColumnsPanel;
		// 添加到输出条件框
		targetPanel.makeOutputDropObject(targetPanel, attr,
				false);
	},

	/**
	 * 显示过滤条件编辑
	 * 
	 * @param btnId
	 *            过滤选项对象
	 */
	filterConditionEdit : function(btnId) { // 过滤条件编辑
		var tip = Ext.getCmp('condition-edit'); // 取得展现的tooltip对象
		if (tip == null) {
			this.initFilterTooltip();
			if (this.initFilterTooltip() == null) {
				this.initFilterTooltip = function() {
					new Ext.ToolTip({ // 提示框
						id : 'show-condition-tooltip',
						anchor : 'top',
						dismissDelay : 2000,
						animate : true,
						hidden : true,
						autoDestroy : false,
						cls : 'splitbutton-zindex-h',
						items : [ {
							xtype : 'label',
							text : ''
						} ]
					}).hide();
				};
			}

			tip = Ext.getCmp('condition-edit');
			if (tip == null) {
				new Ext.Window({
					title : conditionfilter.edit,
					id : 'condition-edit',
					anchor : 'bottom',
					parentID : '',
					autoHide : false,
					closable : true,
					hidden : true,
					target : null,
					bodyStyle : 'padding:10px',
					html : null,
					width : 617,
					maxWidth : 617,
					draggable : { // 监控move
						insertProxy : false,
						onDrag : function(e) {
							// biAdhocNs.conditionFilterObj.closeAllTip();
						},
						endDrag : function(e) {
						}
					},
					// show :
					// biAdhocNs.ToolTipPlus.showAtCenter,
					items : [{
						xtype : 'panel',
						id : 'tip-condition-panel',
						width : 585,// 490
						// height : 265,
						autoScroll : false,
						buttonAlign : 'center',
						cls : 'panel-margin',
						/*
						 * tbar :{
						 * style:{padding:'5px,8px,5px,8px'},
						 * items:[{
						 * id:'current-editor-combo',
						 * xtype:'textfield',
						 * width:100, value :
						 * '右项' },{
						 * xtype:'button', text:
						 * '增加字段', iconCls :
						 * 'icon-share-btn-adddir',
						 * tooltipType :
						 * 'title', tooltip :
						 * '增加字段',
						 * handler:function(btn){
						 * biAdhocNs.AdditionalColumns.showAdditionalColumns(biAdhocNs.conditionFilterObj.confirmAddColumns); } },
						 * '-',
						 * biAdhocNs.FunctionEdit.getFunctionMainFrame(300,biAdhocNs.conditionFilterObj.fxTextFieId,biAdhocNs.conditionFilterObj.confirmMakeFunction) ] },
						 */
						items : [ {
							layout : 'column',
							border : false,
							defaults : {
								hideLabel : true
							},
							items : [{
								columnWidth : .37,
								xtype : 'fieldset',
								title : conditionfilter.leftColumn,
								id : 'left-fieldset',
								autoHeight : false,
								cls : ((Ext.isIE6) ? 'availableLot-filter-x-ie6'
										: 'availableLot-filter-x'),
								height : 224,
								listeners : {
									'afterrender' : function(
											fset) {
										biAdhocNs.conditionFilterObj
												.setContentEditable(
														fset,
														'fset-left-content-box',
														true); // 设置为编辑
									}
								}
							},
							{
								columnWidth : .25,
								xtype : 'fieldset',
								title : conditionfilter.operator,
								id : 'center-op-char',
								cls : ((Ext.isIE6) ? 'availableLot-filter-x-ie6'
										: 'availableLot-filter-x'),
								autoHeight : false,
								height : 224,
								html : biAdhocNs.conditionFilterObj
										.getOpCharMultSelect()
							},
							{
								columnWidth : .37,
								xtype : 'fieldset',
								title : conditionfilter.rightValue,
								id : 'right-fieldset',
								cls : ((Ext.isIE6) ? 'availableLot-filter-x-ie6'
										: 'availableLot-filter-x'),
								autoHeight : false,
								height : 224,
								items : [{
									xtype : "datefield",
									id : "datefieldId",
									format : "Ymd",
									fieldLabel : conditionfilter.date,
									width : 90,
									listeners : {
										select : function() {
											Ext.getDom('fset-right-content-box').innerText = this.value;
										}
									}
								},
								{
									title : '',
									html : '<div id="dateTest" style="z-index=100"></div>'
								} ],
								listeners : {
									'beforerender' : function(fset) {
										Ext.getCmp('datefieldId').hide();
										var tip = Ext.getCmp('condition-edit'); // 获取展示tooltip对象
										var btn = Ext.getCmp(tip.parentID);
										var colTypeFlag = btn.attributes.colType;
										if (colTypeFlag == 3) {
											Ext.getCmp('datefieldId').format = 'Ymd';
											Ext.getCmp('datefieldId').show();
										}
										if (colTypeFlag == 4) {
											Ext.getCmp('datefieldId').format = 'Ym';
											Ext.getCmp('datefieldId').show();
										}
									},
									'afterrender' : function(fset) {
										var onclick = 'biAdhocNs.conditionFilterObj.showReferenceValue();';
										fset.header.createChild({
													tag : 'a',
													href : '#',
													onclick : onclick,
													html : conditionfilter.exampleValues
												});
										biAdhocNs.conditionFilterObj.setContentEditable(
														fset,
														'fset-right-content-box',
														true); // 设置为编辑
									}
								}
							}]
						} ]
					},
					{
						xtype : 'radiogroup',
						hideLabel : true,
						id : 'parameter-type-id',
						cls : 'condition-radio-group',
						items : [{
							xtype : 'radio',
							checked : true,
							boxLabel : conditionfilter.valueParameter,
							name : "paramType", // 用于form提交时传送的参数名
							inputValue : "valuePara" // 提交时传送的参数值
						}, {
							xtype : 'radio',
							boxLabel : conditionfilter.formalParameter,
							name : "paramType",
							inputValue : "formalPara"
						} ]
					},
					{
						xtype : 'button',
						text : conditionfilter.save,
						cls : 'condition-button-margin-x',
						iconCls : 'icon-accept',
						handler : function() {
							biAdhocNs.conditionFilterObj
									.saveDesign(); // 处理保存
						}
					}],
					listeners : {
						hide : function(tip) {
							try {
								// tip.unbindTarget();
								// 此接口方法来源于showtree.js
								Ext.getCmp('info-window').hide(); // 隐藏维表或者编码表值弹出框
								Ext.getCmp('show-use-input').hide(); // 隐藏输入框
								// Ext.getCmp('show-more-operation-select').hide();
								// 隐藏操作符选择框
								Ext.getCmp('info-function-window').hide(); // 隐藏函数选择框
								// 清空函数输入框中的所有内容
								/*
								 * var tf =
								 * Ext.getCmp(biAdhocNs.conditionFilterObj.fxTextFieId);
								 * tf.setValue('');
								 * tf.fxModels = [];
								 */
							} catch (e) {
							}
						},
						beforeshow : function(tip) {
							try {
								Ext.getDom('fset-left-content-box').innerHTML = '';
								Ext.getDom('fset-right-content-box').innerHTML = '';
							} catch (e) {
							}
						},
						show : function(tip) { // 还原对象
							tip.header.dom.style.cursor = 'move';
							var btn = Ext.getCmp(tip.parentID);
							var left_cb = Ext.getDom('fset-left-content-box');
							left_cb.onfocus = null;
							left_cb.innerHTML = biAdhocNs.conditionFilterObj.makeSpan(
											btn.attributes.tableCName + '{' + btn.text + '}', 
											'scolumn',
											btn.text);
							// left_cb.innerHTML =
							// btn.saveLeftHTML != '' ?
							// btn.saveLeftHTML :
							// biAdhocNs.conditionFilterObj.makeSpan(btn.atext,
							// 'scolumn', btn.avalue);

							var right_cb = Ext
									.getDom('fset-right-content-box');
							// right_cb.innerHTML =
							// btn.saveRightHTML;
							right_cb.innerHTML = '';

							biAdhocNs.conditionFilterObj.currentSplitButtonID = tip.parentID; // 保存当前操作的buttonID
							// biAdhocNs.conditionFilterObj.restoreOP(btn.opChar);

							// 设置属于、不属于是否可视
							/*
							 * if(btn.attributes.colType ==
							 * biAdhocNs.COLTYPE_CODE){
							 * biAdhocNs.MultSelect.setRowDisplay('multselect',4,'');
							 * //biAdhocNs.MultSelect.setRowDisplay('multselect',8,'');
							 * }else{
							 * biAdhocNs.MultSelect.setRowDisplay('multselect',4,'none');
							 * //biAdhocNs.MultSelect.setRowDisplay('multselect',8,'none'); }
							 */
							// 清空函数输入框中的所有内容
							/*
							 * var tf =
							 * Ext.getCmp(biAdhocNs.conditionFilterObj.fxTextFieId);
							 * tf.setValue('');
							 * tf.fxModels = []; //设置
							 * 函数第一个参数的 值为拖入进来的字段
							 * biAdhocNs.FunctionEdit.setCurrentBtnAttribute(btn.attributes,biAdhocNs.conditionFilterObj.fxTextFieId);
							 */

							/*
							 * (function() { // 延时1.5秒
							 * 光标定位到右项编辑框
							 * ,防止左项还原值时的focus冲突 try{
							 * right_cb.focus(); //
							 * 光标定位到右项编辑框 }catch(e){}
							 * }).defer(800);
							 */
							Ext.getCmp('datefieldId').hide();
							var tip = Ext.getCmp('condition-edit'); // 获取展示tooltip对象
							var btn = Ext.getCmp(tip.parentID);
							var colTypeFlag = btn.attributes.colType;
							if (colTypeFlag == 3) {
								Ext.getCmp('datefieldId').format = 'Ymd';
								Ext.getCmp('datefieldId').show();
							}
							if (colTypeFlag == 4) {
								Ext.getCmp('datefieldId').format = 'Ym';
								Ext.getCmp('datefieldId').show();
							}
						}
					}
				}).hide();
				tip = Ext.getCmp('condition-edit');
			}
		}
		tip.parentID = btnId;
		// tip.initTarget(btnId);
		tip.show();
	},

	/**
	 * SPAN模板的对象
	 */
	rightElementTemplate : new Ext.Template(
			'<SPAN valign="top" title="{columnName}" CLASS="availableLot-box-{cls}" CONTENTEDITABLE="{editable}"',
			' ONRESIZESTART="javascript:return false"  ><SPAN style="display:none">{demensionChar}</SPAN>{text}<SPAN style="display:none">{demensionCompKey}</SPAN><SPAN style="display:none">{demensionChar}</SPAN></SPAN>'),

	/**
	 * 过滤选项模板对象
	 */
	splitButtonTemplate : new Ext.Template(
			'<table id="{4}" cellspacing="0" class="x-btn {3}"><tbody class="{1}">',
			'<tr><td class="x-btn-tl x-btn-tl-6"><i>&#160;</i></td><td class="x-btn-tc x-btn-tc-6"></td><td class="x-btn-tr x-btn-tr-6"><i>&#160;</i></td></tr>',
			'<tr><td class="x-btn-ml x-btn-ml-6"><i>&#160;</i></td><td class="x-btn-mc x-btn-mc-6"><em class="{2}" unselectable="on"><button type="{0}"></button></em></td><td class="x-btn-mr x-btn-mr-6"><i>&#160;</i></td></tr>',
			'<tr><td class="x-btn-bl x-btn-bl-6"><i>&#160;</i></td><td class="x-btn-bc x-btn-bc-6"></td><td class="x-btn-br x-btn-br-6"><i>&#160;</i></td></tr>',
			'</tbody></table>'),

	/**
	 * 组合字段把提示打出来(根据鼠标坐标)
	 * 
	 * @param msg
	 *            显示内容
	 */
	showAlterTipByMouseXY : function(msg) { // 组合字段把提示打出来(根据鼠标坐标)
		var tip = Ext.getCmp('show-condition-tooltip');
		tip.items.items[0].setText(msg);
		tip.showAt([ event.clientX, event.clientY ]);
	},
	/**
	 * 获取括号组件
	 * 
	 * @param {}
	 *            model
	 * @return {}
	 */
	generalParenthesisComp : function(type) {
		return { // 加入对象
			xtype : 'splitbutton',
			text : '',
			allowDomMove : true,
			scale : 'parenthesis',
			arrowAlign : 'bottom',
			iconCls : type == '(' ? 'parenthesis-left'
					: 'parenthesis-right',
			cls : 'availableLot-x',
			compType : type,
			menu : {
				items : [ {
					text : conditionfilter.del,
					iconCls : 'delete',
					handler : function(item) {
						var btnid = item.parentMenu.ownerCt.id;
						var panel = Ext
								.getCmp('group-condition-filter-panel');
						panel.removeParenthesis(btnid);
					}
				} ]
			}
		};
	},

	/**
	 * 显示参考值选择框
	 */
	showReferenceValue : function() {// 显示参考值选择框
		var id = this.currentSplitButtonID;
		var btn = Ext.getCmp(id);// this.oprationChar

		if ((trim(this.oprationChar) == 'IN' || trim(this.oprationChar) == 'NOT IN')
				&& btn.attributes.colType == 3) {

		} else {
			this.makeDataGridPanelByShow(btn.attributes,
					this.oprationChar, 'right-fieldset');// btn.opChar.trim()
			var tip = Ext.getCmp('show-use-input');
			Ext.getCmp('datefieldId').hide();
			tip.hide();
			// Ext.getCmp('show-more-operation-select').hide();//隐藏更多操作符选择框
		}

	},

	/**
	 * 维表数据展现
	 * 
	 * @param attributes
	 *            过滤字段attributes对象
	 * @param opchar
	 *            过滤操作符
	 * @param target
	 */
	makeDataGridPanelByShow : function(attributes, opchar, target) { // 维表数据展现
		var atts = attributes;
		var nt = atts.colType;

		/*
		 * if (nt == biAdhocNs.COLTYPE_CODE) { } else if (nt ==
		 * biAdhocNs.COLTYPE_DEMENSION || nt ==
		 * biAdhocNs.COLTYPE_NO_TABLE_DEMENSION) { } else if (nt ==
		 * biAdhocNs.COLTYPE_INTRVAL) { // 日期 } else {//
		 * 普通类型显示一个空窗口 }
		 */
		Ext.getCmp('datefieldId').hide();
		var btn = Ext.getCmp(this.currentSplitButtonID); // 获取当前操作的splitbutton
		var store = new Ext.data.Store({// 配置分组数据集
			baseParams : {
				table : btn.attributes.tableName,
				column : btn.attributes.name,
				columnId : btn.attributes.columnId,
				colType : btn.attributes.colType
			},
			reader : new Ext.data.JsonReader({
				totalProperty : "count",
				root : "conditonVal",
				// 要读取出来的字段
				fields : [ 'name', 'value' ]
			}),
			proxy : new Ext.data.HttpProxy({
				url : [ biAdhocNs.sysUrl,
						'chart/chart/defaultValue' ].join('')
			})
		});
		store.load({
			params : {
				start : 0,
				limit : 10
			}
		});// 传递参数
		var checkBoxSelMod = new Ext.grid.CheckboxSelectionModel();// 定义复选框
		var grid = new Ext.grid.GridPanel({
			id : 'dimension-select-grid2',
			store : store,
			cls : 'panel-margin',
			border : false,
			colType : nt, // 节点类型
			selModel : checkBoxSelMod,
			columns : [ checkBoxSelMod, {
				header : conditionfilter.name,
				dataIndex : 'name'
			}, {
				header : conditionfilter.value,
				dataIndex : 'value',
			} ],
			stripeRows : true,
			loadMask : true,
			height : 300,
			stateful : true,
			enableHdMenu : false,
			viewConfig : {
				forceFit : true
			},
			bbar : new Ext.PagingToolbar({
				pageSize : 10,// 每页显示的记录值
				store : store,
				displayInfo : true,
				displayMsg : conditionfilter.totalRecodes + ' {0} - {1} of {2}',
				emptyMsg : conditionfilter.noRecodes
			}),
			fbar : [{
				text : conditionfilter.OK,
				iconCls : 'icon-confirm',
				handler : function() {
					var selChk = '';
					var rec = grid.selModel.selections.items;
					for (var i = 0; i < rec.length; i++) {
						selChk += rec[i]
								.get("value");
						if (i < rec.length - 1) {
							selChk = selChk
									+ ",";
						}
					}
					var right_cb = Ext
							.getDom('fset-right-content-box');
					right_cb.innerHTML = selChk;
					Ext.getCmp('info-window')
							.hide();
				}
			},
			{
				text : conditionfilter.selectAll,
				iconCls : 'icon-full-select',
				handler : function() {
					grid.getSelectionModel()
							.selectAll();
					// grid.getSelectionModel().clearSelections();
					var selChk = '';
					var rec = grid.selModel.selections.items;
					for (var i = 0; i < rec.length; i++) {
						selChk += rec[i]
								.get("value");
						if (i < rec.length - 1) {
							selChk = selChk
									+ ",";
						}
					}
					var right_cb = Ext
							.getDom('fset-right-content-box');
					right_cb.innerHTML = selChk;
					Ext.getCmp('info-window')
							.hide();
				}
			},
			{
				xtype : 'label',
				html : '<div style="width:125px"></div>',
				disabled : true
			} ]
		});
		var win = Ext.getCmp('info-window');
		if (win == null) {
			var win = new Ext.Window({
				id : 'info-window',
				// anchor : 'right',
				autoHide : false,
				closable : true,
				hidden : true,
				draggable : true,
				width : 670,
				html : null,
				target : null,
				// show : biAdhocNs.ToolTipPlus.showAtCenter,
				cls : 'splitbutton-zindex',
				gird : null,
				items : [],
				listeners : {
					beforeshow : function(tip) { // 展示前清空里面所有对象
						var len = tip.items.length;
						if (len > 0) {
							tip.removeAll(true);
							tip.doLayout();
						}
					},
					show : function(tip) { // 展示时把对象加进去
						if (tip.grid != null) {
							tip.add(tip.grid);
							tip.doLayout();
						}
					}
				}
			}).hide();
		}
		win.setTitle([ '“', attributes.text, '”' + conditionfilter.dateForSelect ]
				.join(''));
		win.grid = grid;
		// win.initTarget(target);
		win.show();

	},
	/**
	 * 获取案例的GRID
	 * 
	 */
	getInstanceGrid : function(nt, atts, opchar) {

		// 定义数据集对象
		var store = new Ext.data.Store({// 配置分组数据集
			reader : new Ext.data.JsonReader(),
			proxy : new Ext.data.HttpProxy({
				url : [ biAdhocNs.sysUrl,
						'adhocquery/ScanInstance.action' ]
						.join('')
			})
		});
		store.load({
			params : {
				start : 0,
				limit : 20,
				search : ''
			}
		});

		// 创建Grid表格组件
		var grid = new Ext.grid.GridPanel({
			id : 'instanceData-id',
			// width : 580,
			height : 310,
			title : '案例数据',
			border : true,
			frame : false,

			bbar : new biAdhocNs.pagingToobar({
				store : store,
				goButton : true,
				pageSize : 20,
				displayInfo : true,
				doLoad : function(start) {
					var o = {}, pn = this.getParams();
					o[pn.start] = start;
					o[pn.limit] = this.pageSize;
					o.search = Ext.getCmp(
							'searchInstanceTextId')
							.getValue();
					if (this.fireEvent('beforechange', this, o) !== false) {
						this.store.load({
							params : o
						});
					}
				}
			}),
			store : store,
			colType : nt, // 节点类型
			textCol : atts.textColName, // 维表中文字段
			valueCol : atts.valueColName, // 维表英文字段
			dataType : atts.dataType, // 数据类型
			showType : atts.showType, // 展示类型

			columns : [// 配置表格列
			// new Ext.grid.RowNumberer(),//表格行号组件
			{
				header : "Id",
				width : 50,
				dataIndex : 'query_id',
				sortable : true,
				hidden : true
			}, {
				header : "案例名称",
				width : 130,
				dataIndex : 'query_name',
				sortable : true
			}, {
				header : "案例描述",
				width : 130,
				dataIndex : 'query_desc',
				sortable : true
			}, {
				header : "创建时间",
				width : 130,
				dataIndex : 'create_time',
				sortable : true
			} ],
			fbar : [{
				text : '确定',
				iconCls : 'icon-confirm',
				handler : function() {
					biAdhocNs.conditionFilterObj.singleDataSelect(
									opchar,
									'instanceData-id'); // 单选
				}
			}, {
				xtype : 'label',
				html : '<div style="width:165px"></div>',
				disabled : true
			} ],
			// 添加的工具条
			tbar : [
				' ',
				new Ext.form.TextField({
					// fieldLabel:'查找关键字',
					id : 'searchInstanceTextId',
					width : '300',
					emptyText : '输入要查找的信息......',
					enableKeyEvents : true,
					listeners : {
						'keydown' : function(
								tf, e) {
							if (e.getKey() == 13) { // 用户按回车键后提交数据
								searchTb_bt();
								Ext
										.getCmp(
												'searchInstanceResetButtonId')
										.show();

							}
						}
					}
				}),
				' ',
				' ',
				{
					id : 'searchInstanceResetButtonId',
					iconCls : 'removegridpanel',
					tooltip : '复原',
					hidden : true,
					width : '35',
					handler : function() {
						Ext.getCmp('searchInstaceTextId').reset();
						Ext.getCmp('searchInstanceButtonId').show();
						Ext.getCmp('searchInstanceResetButtonId').hide();
						searchTb_bt();
					},
					scope : this
				},
				{
					id : 'searchInstanceButtonId',
					iconCls : 'icon-search-column',
					tooltip : '搜索',
					width : '35',
					handler : function() {
						searchTb_bt();
						Ext.getCmp('searchInstanceButtonId').show();
					},
					scope : this
				} 
			]
		});

		var searchTb_bt = function() {
			store.load({
				params : {
					start : 0,
					limit : 20,
					search : Ext.getCmp('searchInstanceTextId').getValue()
				}
			});
		};

		return grid;
	},
	/**
	 * 检测某个数组中是否有相同的值 ，以value为唯一值
	 * 
	 * @param groups
	 *            数组
	 * @param v
	 *            唯一值
	 */
	arrayHasSame : function(groups, v) { // 检测某个数组中是否有相同的值
											// ，以value为唯一值
		var size = groups.length;
		for (var j = 0; j < size; j++) {
			if (groups[j].value == v)
				return true;
		}
		return false;
	},

	/**
	 * 检测某个数组中是否有相同的值 ，以key为唯一值
	 * 
	 * @param groups
	 *            数组
	 * @param key
	 *            唯一值
	 */
	arrayHasSameForKey : function(groups, key) { // 检测某个数组中是否有相同的值
													// ，以key为唯一值
		var size = groups.length;
		for (var j = 0; j < size; j++) {
			if (groups[j].key == key)
				return true;
		}
		return false;
	},

	/**
	 * 确定参考值选择
	 */
	singleDataSelect : function(opchar, gridId) {
		// 单选
		var btn = Ext.getCmp(this.currentSplitButtonID); // 获取当前操作的splitbutton
		var gridpanel = Ext.getCmp(gridId); // 获取数据gridpanel
											// 'dimension-select-grid2'
		var coltype = gridpanel.colType;
		btn.dimensionGroup.push({
			key : '20133',
			value : '20139'
		}); // 保存相应的值
		Ext.getCmp('info-window').hide();
	},

	/**
	 * 根据类型返回<SPAN>标签
	 * 
	 * @param text
	 *            显示内容
	 * @param type
	 *            类型
	 * @param columnName
	 *            提示的title值
	 */
	makeSpan : function(text, type, columnName) { // 根据类型返回<SPAN>标签
		columnName = columnName || '';
		type = type || 'dcolumn';

		return this.rightElementTemplate.apply({
			columnName : columnName,
			cls : type,
			editable : (type == 'fun' || type == 'coll') ? 'true'
					: 'false',
			text : text,
			demensionChar : type == 'value' ? biAdhocNs.ORIGO_DEMENSION_CHAR
					: '',
			demensionCompKey : type == 'value' ? [ '_',
					columnName ].join('') : '' // 如果为维字段信息，组合key值为
												// text_value
		});
		/*
		 * return ['<SPAN valign="top" title="', columnName, '"
		 * CLASS="availableLot-box-', cls, '"
		 * CONTENTEDITABLE="', ((type == 'FUN' || type ==
		 * 'COLL') ? 'true' : 'false'), '"
		 * ONRESIZESTART="javascript:return false">', text, '<SPAN
		 * style="display:none">', ((cls == 'value') ?
		 * biAdhocNs.ORIGO_DEMENSION_CHAR : ''), '</SPAN></SPAN>'].join('');
		 */
	},

	/**
	 * 返回multselect操作符对象
	 */
	getOpCharMultSelect : function() {
		var ops = [ {
			id : 'make-equ',
			name : conditionfilter.equalTo,
			op : '=',
			desc : '',
			count : ''
		}, {
			id : '',
			name : conditionfilter.greaterThan,
			op : '>',
			desc : '',
			count : ''
		}, {
			id : '',
			name : conditionfilter.lessThan,
			op : '<',
			desc : '',
			count : ''
		}, {
			id : 'make-in',
			name : conditionfilter.inner,
			op : ' IN ',
			desc : '',
			count : ''
		}, {
			id : 'exists',
			name : conditionfilter.exists,
			op : ' EXISTS ',
			desc : '',
			count : ''
		}, {
			id : 'make-like',
			name : conditionfilter.like,
			op : ' LIKE ',
			desc : '',
			count : ''
		}, {
			id : 'make-between',
			name : conditionfilter.between,
			op : ' BETWEEN ',
			desc : '',
			count : ''
		}, {
			id : 'make-area',
			name : conditionfilter.area,
			op : ' AREA ',
			desc : '',
			count : ''
		}, {
			id : 'make-isnull',
			name : conditionfilter.isnull,
			op : ' IS ',
			desc : '',
			count : ''
		}, {
			id : 'choose-in-more-op',
			name : '',
			op : ' ', // 保持op为一个空格
			desc : '',
			count : ''
		} /*
		 * ,{ id : 'condition-more-op', name : '<a
		 * href="#">更多...</a>', op : ' ', //保持op为一个空格
		 * 确保初始化打开的时候区别于传进来的空值OP desc : '', count : '' }
		 */];
		var click = 'biAdhocNs.conditionFilterObj.selectedOK(this);';
		biAdhocNs.MultSelect.setMultSelectID('multselect');
		biAdhocNs.MultSelect.setDatas(ops);
		biAdhocNs.MultSelect.setCilckFunction(click);
		return biAdhocNs.MultSelect.makeMultSelect(); // 生成multselect
	},

		/**
		 * 返回更多的multselect操作符对象
		 */
	getMoreOpCharMultSelect : function() {
		var ops = [ {
			id : '',
			name : '不等于(!=)',
			op : '!=',
			desc : '',
			count : ''
		}, {
			id : '',
			name : '大于等于(>=)',
			op : '>=',
			desc : '',
			count : ''
		}, {
			id : '',
			name : '小于等于(<=)',
			op : '<=',
			desc : '',
			count : ''
		}, {
			id : 'not-make-in',
			name : '不在...中(NOT IN)',
			op : ' NOT IN ',
			desc : '',
			count : ''
		}, {
			id : 'notexists',
			name : '不属于(NOT EXISTS)',
			op : ' NOT EXISTS ',
			desc : '',
			count : ''
		}, {
			id : 'not-make-like',
			name : '非类似(NOT LIKE)',
			op : ' NOT LIKE ',
			desc : '',
			count : ''
		}, {
			id : 'not-make-between',
			name : '不在...之间(NOT BETWEEN)',
			op : ' NOT BETWEEN ',
			desc : '',
			count : ''
		}, {
			id : 'make-isnotnull',
			name : '不为空(IS NOT)',
			op : ' IS NOT ',
			desc : '',
			count : ''
		} ];
		var click = 'biAdhocNs.conditionFilterObj.selectedMoreOpOK(this);';
		biAdhocNs.MultSelect.setMultSelectID('more-op-multselect');
		biAdhocNs.MultSelect.setDatas(ops);
		biAdhocNs.MultSelect.setCilckFunction(click);
		return [ biAdhocNs.MultSelect.makeMultSelect(), ops ]; // 生成multselect
	},

	/**
	 * 返回like操作符弹出的html标签
	 */
	makeLikeTag : function() {
		return '<div CLASS="box-border-set panel-margin"><TABLE WIDTH="75%" BORDER="0" class="table-word-size"><TR><TD ALIGN="CENTER">' 
		+ conditionfilter.leftBorder + '</TD><TD ALIGN="CENTER">' 
		+ conditionfilter.value + '</TD><TD ALIGN="CENTER">' 
		+ conditionfilter.rightBorder + '</TD></TR><TR><TD ALIGN="CENTER"><INPUT TYPE="text" id="side1" SIZE="5" CLASS="box-border-set" value="\'%"></TD><TD ALIGN="CENTER"><INPUT TYPE="text" id="side2" SIZE="10" CLASS="box-border-set"></TD><TD ALIGN="CENTER"><INPUT TYPE="text" id="side3" SIZE="5" CLASS="box-border-set" value="%\'"></TD></TR><TR><TD ALIGN="CENTER" COLSPAN="3"><INPUT TYPE="button" value="' 
		+ conditionfilter.OK + '" CLASS="btn-new-css" onclick="biAdhocNs.conditionFilterObj.addToFieldset(\'LIKE\')"></TD></TR></TABLE></div>';
	},

	/**
	 * 返回between操作符弹出的html标签
	 */
	makeBetweenTag : function() {
		return '<div CLASS="box-border-set panel-margin"><TABLE WIDTH="75%" BORDER="0" class="table-word-size"><TR><TD ALIGN="CENTER">'
		+ conditionfilter.leftValue + '</TD><TD ALIGN="CENTER">&nbsp;</TD><TD ALIGN="CENTER">' 
		+ conditionfilter.rightValue + '</TD></TR><TR><TD ALIGN="CENTER"><INPUT TYPE="text" id="side1" SIZE="9" CLASS="box-border-set" value=""></TD><TD ALIGN="CENTER">AND</TD><TD ALIGN="CENTER"><INPUT TYPE="text" id="side2" SIZE="9" CLASS="box-border-set" value=""></TD></TR><TR><TD ALIGN="CENTER" COLSPAN="3"><INPUT TYPE="button" value="'+ conditionfilter.OK +'" CLASS="btn-new-css"  onclick="biAdhocNs.conditionFilterObj.addToFieldset(\'BETWEEN\')"></TD></TR></TABLE></div>';
	},

	/**
	 * 返回区间操作符弹出的html标签
	 */
	makeAreaTag : function() {
		// 取字段信息
		var rTip = Ext.getCmp('condition-edit')
		var btn = Ext.getCmp(rTip.parentID);
		var right_cb = Ext.getDom('fset-right-content-box');
		return '<DIV class="box-border-set panel-margin"><TABLE class=table-word-size border=0 width="75%"><TR><TD align=middle>' 
		+ conditionfilter.leftValue + '</TD><TD align=middle>&nbsp;</TD><TD align=middle>&nbsp;</TD><TD align=middle>&nbsp;</TD><TD align=middle>' 
		+ conditionfilter.rightValue + '</TD></TR><TR><TD align=middle><INPUT id=side1 class=box-border-set size=7></TD><TD align=middle><SELECT id=side3 name=menuD1> <OPTION selected value="<">&lt;</OPTION> <OPTION value="<=">&lt;=</OPTION></SELECT> </TD><TD align=middle>' 
		+ conditionfilter.columnName + '</TD><TD align=middle><SELECT id=side4 name=menuD1> <OPTION selected value="<">&lt;</OPTION> <OPTION value="<=">&lt;=</OPTION></SELECT> </TD><TD align=middle><INPUT id=side2 class=box-border-set size=7></TD></TR><TR><TD align=middle>&nbsp;</TD><TD colSpan=3 align=middle><INPUT class=btn-new-css onclick="biAdhocNs.conditionFilterObj.addToAreaset(\'AREA\')" value="' 
		+ conditionfilter.OK + '" type=button></TD><TD align=middle>&nbsp;</TD></TR></TABLE></DIV>';
	},

	/**
	 * 还原op操作符选择项
	 * 
	 * @param op
	 *            需要还原的操作符
	 */
	restoreOP : function(op) { // 还原
		var chooseInMore = Ext.getDom('choose-in-more-op'); // 保存从更多操作符中选择的操作符对象
		chooseInMore.value = '';
		chooseInMore.cells[0].innerText = '';
		chooseInMore.className = '';

		var table = Ext.getDom('multselect');
		var rows = table.rows;
		var rlen = rows.length;
		for (var i = 0; i < rlen; i++) {
			if (rows[i].className == 'mouse-click') {
				rows[i].className = '';
				break;
			}
		}
		for (var i = 0; i < rlen; i++) {
			if (rows[i].value == op) {
				rows[i].className = 'mouse-click';
				this.oprationChar = op; // 保存操作符
				return;
			}
		}
		/** ********还原从更多操作符中选择的操作符********* */
		var ops = Ext.getCmp('more-operation-select-fieldset').ops;
		for (var i = 0; i < ops.length; i++) {
			if (ops[i].op == op) {
				chooseInMore.value = ops[i].op;
				chooseInMore.cells[0].innerText = ops[i].name;
				chooseInMore.className = 'mouse-click';
				return;
			}
		}

	},

	/**
	 * 替换一些不必要的字符,字段名称替换成字段英文名称，维数据text替换成value
	 * 
	 * @param text
	 *            需要被替换的内容
	 * @param item
	 *            过滤对象
	 */
	replaceSomeObject : function(text, item) { // 替换一些不必要的字符
		// 替换源字段

		text = text.replaceAll(item.atext, item.avalue); // 替换源字段
		// 替换其它字段
		for (var i = 0; i < item.columnGroup.length; i++) {
			text = text.replaceAll(item.columnGroup[i].key,
					item.columnGroup[i].value);
		}
		// 替换维表字段值
		var size = item.dimensionGroup.length;
		for (var j = 0; j < size; j++) {
			var key = [ biAdhocNs.ORIGO_DEMENSION_CHAR,
					item.dimensionGroup[j].key,
					biAdhocNs.ORIGO_DEMENSION_CHAR ].join('');
			if (key.indexOf('(') >= 0 || key.indexOf(')') >= 0) { // 替换存在左右括号（）的字符创
				while (text.indexOf(key) >= 0) {
					text = text.replace(key,
							item.dimensionGroup[j].value);// 替换值
				}
			} else {
				text = text.replaceAll(key,
						item.dimensionGroup[j].value); // 替换值
			}
		}
		return text;
	},

	/**
	 * 替换一些不必要的字符,字段名称替换成字段英文名称，维数据text_value替换成value
	 * 
	 * @param text
	 *            需要被替换的内容
	 * @param btn
	 *            过滤对象
	 */
	replaceDimenKeyToText : function(text, btn) { // key的组成为（text_value）替换维信息为text
		var size = btn.dimensionGroup.length;
		for (var j = 0; j < size; j++) {
			var key = [ biAdhocNs.ORIGO_DEMENSION_CHAR,
					btn.dimensionGroup[j].key,
					biAdhocNs.ORIGO_DEMENSION_CHAR ].join('');
			var value_index = key.indexOf([ '_',
					btn.dimensionGroup[j].value ].join('')); // _value
																// 在key中的位置
			if (value_index > 0) { // key中加载了 _value的值
				var key_text = key.substring(0, value_index);
				if (key.indexOf('(') >= 0
						|| key.indexOf(')') >= 0) { // 替换存在左右括号（）的字符创
					while (text.indexOf(key) >= 0) {
						text = text.replace(key, key_text);// 替换成text
					}
				} else {
					text = text.replaceAll(key, key_text); // 替换成text
				}
			}
		}
		return text;
	},

	/**
	 * 返回str中是否有IN 、LIKE、BETWEEN等操作符
	 * 
	 * @param str
	 *            字符串
	 * @return 返回boolean类型
	 */
	isInLikeBetweenOp : function(str) {
		return str.indexOf('IN') != -1
				|| str.indexOf('LIKE') != -1
				|| str.indexOf('BETWEEN') != -1;
	},

	/**
	 * 根据连接类型返回连接字符串
	 * 
	 * @param n
	 *            连接类型
	 */
	getJoinTypeStr : function(n) {
		if (n == 0)
			return 'LEFT';
		else if (n == 1)
			return 'RIGHT';
		else if (n == 3)
			return 'INNER';
		return 'LEFT';
	},

	/**
	 * 清空所有过滤内容
	 */
	clearAll : function() { // 清空所有
		this.removeAll(true);
		this.doLayout();
	},

	/**
	 * like/between设置保存
	 * 
	 * @param n
	 *            操作符字符串
	 */
	addToFieldset : function(n) { // like/between设置保存
		var side1 = Ext.getDom('side1').value.trim();
		var side2 = Ext.getDom('side2').value.trim();
		var side3;
		var tip = Ext.getCmp('show-use-input');
		var text = '';
		if (n.indexOf('LIKE') != -1) {
			side3 = Ext.getDom('side3').value.trim();
			if (side1 == '' || side2 == '' || side3 == '') {
				return false;
			}
			text = [ ' ', side1, side2, side3, ' ' ].join('');
			this.insertAtCaret(text);
			Ext.getCmp('datefieldId').hide();
			Ext.getDom('fset-right-content-box').innerText = text;
			tip.hide();
		}
		if (n.indexOf('BETWEEN') != -1) {
			if (side1 == '' || side2 == '') {
				return false;
			}
			var re = /^[-]?\d*\.?\d+$/;
			if (!re.test(side1) || !re.test(side2)) {
				// 获得人生中的成功需要的专注与坚持不懈多过天才与机会。
				this.showAlterTipByMouseXY('输入框只能输入数字...');
				return false;
			}
			side1 = parseInt(side1);
			side2 = parseInt(side2);
			if (side1 > side2) {
				this.showAlterTipByMouseXY('左边值不能大于右边值...');
				return false;
			}

			text = [ side1, ' AND ', side2, ' ' ].join('');
			this.insertAtCaret(text);
			Ext.getCmp('datefieldId').hide();
			Ext.getDom('fset-right-content-box').innerText = text;
			tip.hide();
		}
		Ext.getDom('fset-right-content-box').focus(); // 光标定位到右项
	},

	/**
	 * 区间操作 设置保存
	 * 
	 * @param n
	 *            操作符字符串
	 */
	addToAreaset : function(n) { // 区间操作设置保存
		var side1 = Ext.getDom('side1').value.trim();
		var side2 = Ext.getDom('side2').value.trim();
		var side3 = Ext.getDom('side3').value.trim();
		var side4 = Ext.getDom('side4').value.trim();
		var tip = Ext.getCmp('show-use-input');
		var text = '';

		if (n.indexOf('AREA') != -1) {
			if (side1 == '' || side2 == '') {
				return false;
			}
			/*
			 * var re = /^[-]?\d*\.?\d+$/; if(!re.test(side1) ||
			 * !re.test(side2)) { this
			 * .showAlterTipByMouseXY('输入框只能输入数字...'); return
			 * false; } if(side1>side2){ this
			 * .showAlterTipByMouseXY('左边值不能大于右边值...'); return
			 * false; }
			 */

			side1 = parseInt(side1);
			side2 = parseInt(side2);
			var re = /^[-]?\d*\.?\d+$/;
			if (!re.test(side1) || !re.test(side2)) {
				this.showAlterTipByMouseXY('输入框只能输入数字...');
				return false;
			}
			if (side1 > side2) {
				this.showAlterTipByMouseXY('左边值不能大于右边值...');
				return false;
			}

			var t3;
			if (side3 == '<') {
				t3 = '>';
			} else {
				t3 = '>=';
			}

			var t4;
			if (side4 == '<') {
				t4 = '<';
			} else {
				t4 = '<=';
			}

			// 取字段信息
			var rTip = Ext.getCmp('condition-edit');
			var btn = Ext.getCmp(rTip.parentID);
			var right_cb = Ext.getDom('fset-right-content-box');
			// right_cb.innerHTML =
			// biAdhocNs.conditionFilterObj.makeSpan(btn.atext,
			// 'scolumn', btn.avalue);

			// text = [t3,' ', side1, ' and
			// ',biAdhocNs.conditionFilterObj.makeSpan(btn.atext,
			// 'scolumn', btn.avalue),' ',t4,' ' ,side2, '
			// '].join('');
			text = [ t3, ' ', side1, ' and ',
					btn.attributes.name, ' ', t4, ' ', side2,
					' ' ].join('');
			Ext.getCmp('datefieldId').hide();
			this.insertAtCaret(text);
			Ext.getDom('fset-right-content-box').innerText = text;
			tip.hide();
		}
		Ext.getDom('fset-right-content-box').focus(); // 光标定位到右项

	},

	/**
	 * 保存过滤条件设置
	 */
	saveFiltetConditions : function() { // 查询保存接口
		var datas = [];
		var panel = this;
		var len = panel.items.length;
		var comp = null;
		for (var i = 0; i < len; i++) {
			comp = panel.items.items[i];
			var data = {};
			switch (comp.compType) {
			// AND或者OR，括号
			case 'oper':
			case '(':
			case ')':
				data = {
					compType : comp.compType,
					text : comp.getText()
				};
				break;
			// 非操作符
			case 'label':
				data = {
					compType : comp.compType,
					plusCompIndex : comp.plusComp == null ? 0
							: panel.items
									.indexOf(comp.plusComp),// 记录操作符的绑定信息
					text : comp.getText(),
					showTableText : comp.showTableText,
					hiddenTableText : comp.hiddenTableText,
					attributes : comp.attributes,
					leftHTML : comp.saveLeftHTML.replaceAll(
							'\"', '&quot;'),
					rightHTML : comp.saveRightHTML.replaceAll(
							'\"', '&quot;'),
					opChar : comp.opChar,
					dimensionGroup : comp.dimensionGroup,
					columnGroup : comp.columnGroup,
					parameterType : comp.parameterType
				};
				break;
			}
			datas.push(data);
		}
		return Ext.util.JSON.encode(datas); // 转换为字符串
	},

	/**
	 * 从保存的过滤条件中恢复到面板中
	 */
	restoreFiltetConditions : function(json) { // 查询保存后还原接口
		if (json) {
			this.clearAll(); // 清空
			var datas = Ext.util.JSON.decode(json); // 转换为json对象
			var size = datas.length;
			var panel = this;
			var len = 0;
			var btn;
			for (var i = 0; i < size; i++) {
				var data = datas[i];

				switch (data.compType) {
				case 'oper':
					panel.add(this.generalOperComp(data.text));
					break;
				case '(':
				case ')':
					panel
							.add(this
									.generalParenthesisComp(data.compType));
					break;
				case 'label':
					btn = this.addFilterComp(panel,
							data.attributes);
					btn.setText(data.text);
					btn.saveLeftHTML = data.leftHTML
							.replaceAll('\&quot\;', '\"'), // 保存一段HTML(右)。
					btn.saveRightHTML = data.rightHTML
							.replaceAll('\&quot\;', '\"'), // 保存一段HTML(右)。
					btn.opChar = data.opChar;
					btn.dimensionGroup = data.dimensionGroup;
					btn.showTableText = data.showTableText;
					btn.hiddenTableText = data.hiddenTableText;
					btn.parameterType = data.parameterType;
					btn.columnGroup = data.columnGroup != null ? data.columnGroup
							: [];
					if (data.plusCompIndex != 0) {// 还原操作符绑定
						var plusComp = panel.items
								.itemAt(data.plusCompIndex);
						btn.plusComp = plusComp;
					}
					this.refreshBtnTName(btn);
					break;
				}
			}
			panel.doLayout(); // 渲染
		}
	},

	/**
	 * 检测过滤条件是否设置完整接口
	 */
	checkSetFinished : function() { // 检测过滤条件是否设置完整接口
		var obj = this;
		var len = obj.items.length;
		var item;
		var position = 0;
		for (var i = 0; i < len; i++) {
			item = obj.items.items[i];
			if (item.compType != 'label') {
				continue; // 跳过AND或者OR
			}
			position++;
			if (item.opChar == '' || item.saveRightHTML == ''
					|| item.saveLeftHTML == '') {
				Ext.MessageBox.show({
					title : '提示',
					width : 220,
					modal : false,
					msg : [ '第', position, '个过滤条件您还未设置完成！' ]
							.join(''),
					buttons : Ext.MessageBox.OK,
					icon : Ext.MessageBox.ERROR,
					cls : 'splitbutton-zindex'
				});
				return false;
			}
		}
		return true;
	},

	/**
	 * 判断编码表是否关联临时表
	 */
	isCodeRelaTable : function(v) { // 判断编码表是否关联临时表
		var regx = /FQT.[a-zA-Z0-9_]+/g; // 这里使用正则表达式检测手机号码是否带临时表
		return regx.test(v);
	},

	/**
	 * 获取整个过滤条件的数据格式接口
	 */
	getDataConditions : function() { // 获取整个过滤条件的数据格式接口
		var CONDITIONS = [];
		var condition = {};
		var obj = this;
		var csbph = Ext.getDom("HtmlSave"); // 此对象在adhocquery.jsp文件中
		var len = obj.items.length;
		var item = null; // itemParentNode = null;
		var text = '', ctext = '';
		var left, right, cleft, cright;
		for (var i = 0; i < len; i++) {
			item = obj.items.items[i];
			if (item.compType == '(' || item.compType == ')'
					|| item.compType == 'oper') {// 括号类型,AND或者OR
				var value = item.compType == 'oper' ? item.text
						: item.compType;
				condition = {
					ID : '',// 字段ID
					EXP_VALUE : value,// 条件表达式
					EXP_CVALUE : value,// 条件表达式中文描述
					NODE_TYPE : '69',// 节点类型,当节点类型是编码类型时,配合操作符类型进行处理
					TABLE_NAME : '',// 表名
					FIELD_NAME : '',// 字段名称
					EDITED_FIELD_NAME : '',// 可能会对条件的表达式修改,如:field1+field2
					OPER_CHAR : '',// 操作符 = IN > <
					OPER_VALUE : '',// 操作值
					PART_TYPE : '',// 分区类型[1:按月分表的类型:2:按地市分表
					// 3:按地市按月分表]
					DATA_TYPE : '',// 数据类型[数字:NUMBER;字符:VARCHAR]
					LOGIC_OPER : ''
				// 逻辑操作符AND或者OR
				};
				CONDITIONS.push(condition);
				continue;
			}
			// 非操作符
			// 预处理替换值
			// left = item.avalue;

			csbph.innerHTML = item.saveLeftHTML;
			left = csbph.innerText;
			cleft = left.replaceAll(
					biAdhocNs.ORIGO_DEMENSION_CHAR, '');
			left = this.replaceSomeObject(left, item);

			csbph.innerHTML = item.saveRightHTML;
			right = csbph.innerText;
			cright = right.replaceAll(
					biAdhocNs.ORIGO_DEMENSION_CHAR, '');

			right = this.replaceSomeObject(right, item);

			if (item.opChar.indexOf('AREA') != -1) {
				text = [ left, '', right ].join('');
				ctext = [ cleft, '', cright ].join('');
			} else {
				text = [ left, item.opChar, right ].join('');
				ctext = [ cleft, item.opChar, cright ].join('');
			}
			// 以下为生成数据
			attributes = item.attributes;

			if (attributes.colType == biAdhocNs.COLTYPE_CODE && this.isCodeRelaTable(right)) {
				if (item.opChar.indexOf('EXISTS') != -1) {// 属于,不属于
					condition = { // 对于编码表要特殊处理
						ID : attributes.id,// 字段ID
						EXP_VALUE : [ item.opChar,
								' ( select 1 from ', right,
								' tmp_', (1000 + i), ' where ',
								left, ' = ', 'tmp_',
								(1000 + i), '.USR_NBR)' ]
								.join(''),// 条件表达式
						EXP_CVALUE : ctext,// 条件表达式中文描述
						NODE_TYPE : attributes.colType,// 节点类型,当节点类型是编码类型时,配合操作符类型进行处理
						TABLE_NAME : attributes.table.tableName,// 表名
						FIELD_NAME : attributes.name,// 字段名称
						EDITED_FIELD_NAME : left,// 可能会对条件的表达式修改,如:field1+field2
						OPER_CHAR : item.opChar,// 操作符 = IN > <
						OPER_VALUE : 'NULL',// 操作值
						PART_TYPE : attributes.table.tablePartType,// 分区类型[1:按月分表的类型:2:按地市分表
						// 3:按地市按月分表]
						DATA_TYPE : attributes.dataType,// 数据类型[数字:NUMBER;字符:VARCHAR]
						LOGIC_OPER : (item.plusComp == null ? ''
								: item.plusComp.text)
					// 逻辑操作符AND或者OR
					};
				} else {
					condition = { // 对于编码表要特殊处理
						ID : attributes.id,// 字段ID
						EXP_VALUE : [ left, ' IS NOT NULL' ]
								.join(''),// 条件表达式
						EXP_CVALUE : ctext,// 条件表达式中文描述
						NODE_TYPE : attributes.colType,// 节点类型,当节点类型是编码类型时,配合操作符类型进行处理
						TABLE_NAME : attributes.table.tableName,// 表名
						FIELD_NAME : attributes.name,// 字段名称
						EDITED_FIELD_NAME : left,// 可能会对条件的表达式修改,如:field1+field2
						OPER_CHAR : 'IS NOT',// 操作符 = IN > <
						OPER_VALUE : 'NULL',// 操作值
						PART_TYPE : attributes.table.tablePartType,// 分区类型[1:按月分表的类型:2:按地市分表
						// 3:按地市按月分表]
						DATA_TYPE : attributes.dataType,// 数据类型[数字:NUMBER;字符:VARCHAR]
						LOGIC_OPER : (item.plusComp == null ? ''
								: item.plusComp.text)
					// 逻辑操作符AND或者OR
					};
				}
				CONDITIONS.push(condition);
			} else if (attributes.colType == biAdhocNs.COLTYPE_CODE
					&& right.length == 30) {

				if (item.opChar.indexOf('EXISTS') != -1) {// 属于,不属于
					var checkUrl = [ biAdhocNs.sysUrl,
							'adhocquery/sql/checkHasPartitionTable.action' ]
							.join('');
					var param = [ 'id=', right, '&asName=',
							attributes.table.tableAsName ]
							.join('');
					var rs = this.synchronizationAjax(checkUrl,
							param);
					// right=rs.sql;

					right = this.createRandomCode();// 生成30位随机码保存案例ID，以免重复替换
					if (rs.checked == '1') {
						biAdhocNs.subQueryIsPartMonth = true;
					} else {
						// if(!biAdhocNs.subQueryIsPartMonth)
						// biAdhocNs.subQueryIsPartMonth=false;
					}
					if (!biAdhocNs.subQuerySqlsMap
							.containsKey(right)) {
						biAdhocNs.subQuerySqlsMap.add(right,
								rs.sql);
					}
					condition = { // 对于编码表要特殊处理
						ID : attributes.id,// 字段ID
						// EXP_VALUE : [item.opChar,' ( select 1
						// from ',right,' tmp_',(1000+i),' where
						// ',left,' =
						// ','tmp_',(1000+i),'.USR_NBR)'].join(''),//
						// 条件表达式
						EXP_VALUE : [ item.opChar, '(', right,
								')' ].join(''),// 条件表达式
												// $1w1|id,日期|w1w$
						EXP_CVALUE : ctext,// 条件表达式中文描述
						NODE_TYPE : attributes.colType,// 节点类型,当节点类型是编码类型时,配合操作符类型进行处理
						TABLE_NAME : attributes.table.tableName,// 表名
						FIELD_NAME : attributes.name,// 字段名称
						EDITED_FIELD_NAME : left,// 可能会对条件的表达式修改,如:field1+field2
						OPER_CHAR : item.opChar,// 操作符 = IN > <
						OPER_VALUE : 'NULL',// 操作值
						PART_TYPE : attributes.table.tablePartType,// 分区类型[1:按月分表的类型:2:按地市分表
						// 3:按地市按月分表]
						DATA_TYPE : attributes.dataType,// 数据类型[数字:NUMBER;字符:VARCHAR]
						LOGIC_OPER : (item.plusComp == null ? ''
								: item.plusComp.text)
					// 逻辑操作符AND或者OR
					};
				} else {
					condition = { // 对于编码表要特殊处理
						ID : attributes.id,// 字段ID
						EXP_VALUE : [ left, ' IS NOT NULL' ]
								.join(''),// 条件表达式
						EXP_CVALUE : ctext,// 条件表达式中文描述
						NODE_TYPE : attributes.colType,// 节点类型,当节点类型是编码类型时,配合操作符类型进行处理
						TABLE_NAME : attributes.table.tableName,// 表名
						FIELD_NAME : attributes.name,// 字段名称
						EDITED_FIELD_NAME : left,// 可能会对条件的表达式修改,如:field1+field2
						OPER_CHAR : 'IS NOT',// 操作符 = IN > <
						OPER_VALUE : 'NULL',// 操作值
						PART_TYPE : attributes.table.tablePartType,// 分区类型[1:按月分表的类型:2:按地市分表
						// 3:按地市按月分表]
						DATA_TYPE : attributes.dataType,// 数据类型[数字:NUMBER;字符:VARCHAR]
						LOGIC_OPER : (item.plusComp == null ? ''
								: item.plusComp.text)
					// 逻辑操作符AND或者OR
					};
				}
				CONDITIONS.push(condition);
			} else {
				condition = {
					ID : attributes.id,// 字段ID
					EXP_VALUE : text,// 条件表达式
					EXP_CVALUE : ctext,// 条件表达式中文描述
					NODE_TYPE : attributes.colType,// 节点类型,当节点类型是编码类型时,配合操作符类型进行处理
					TABLE_NAME : attributes.table.tableName,// 表名
					FIELD_NAME : attributes.name,// 字段名称
					EDITED_FIELD_NAME : left,// 可能会对条件的表达式修改,如:field1+field2
					OPER_CHAR : item.opChar,// 操作符 = IN > <
					OPER_VALUE : right,// 操作值
					PART_TYPE : attributes.table.tablePartType,// 分区类型[1:按月分表的类型:2:按地市分表
					// 3:按地市按月分表]
					DATA_TYPE : attributes.dataType,// 数据类型[数字:NUMBER;字符:VARCHAR]
					LOGIC_OPER : (item.plusComp == null ? ''
							: item.plusComp.text)
				// 逻辑操作符AND或者OR
				};
				CONDITIONS.push(condition);
			}
		}
		return CONDITIONS;
	},

		/**
		 * 获取所有维度字段信息接口
		 */
	getDataDemensions : function() { // 获取所有维度字段信息接口
		var DEMENSIONS = [];
		var demension = {};
		var obj = this;
		var len = obj.items.length;
		var item = null;// , itemParentNode = null;
		var serial = 0, right;
		var csbph = Ext.getDom("HtmlSave"); // 此对象在adhocquery.jsp文件中
		for (var i = 0; i < len; i++) {
			item = obj.items.items[i];
			if (item.compType != 'label') // 跳过AND或者OR，左右括号
				continue;
			csbph.innerHTML = item.saveRightHTML;
			right = csbph.innerText;
			right = this.replaceSomeObject(right, item);
			// 以下为生成数据
			attributes = item.attributes;

			serial = 2000 + i;
			// 屏蔽掉当条件出现维度时，提供关联关系chencs20100714
			if (attributes.colType == biAdhocNs.COLTYPE_DEMENSION && false) { // 非操作符
				demension = {
					SERIAL_ID : serial,
					SOURCE_DEST_FILED_REL : [ {
						SOURCE_FIELD_NAME : attributes.name,// 关联源表字段
						SOURCE_TABLE_NAME : attributes.table.tableName,// 关联源表名称
						SOURCE_TABLE_AS_NAME : attributes.table.tableAsName,// 关联源表别名
						DEST_FIELD_NAME : attributes.valueColName,// 目标字段名称
						DEST_TABLE_NAME : attributes.relaTable,// 目标表名称
						DEST_TABLE_AS_NAME : attributes.asName
					// 目标表别名
					} ],
					JOIN_TABLE_NAME : attributes.relaTable,
					JOIN_TABLE_ALIAS : attributes.asName,
					JOIN_TYPE : this
							.getJoinTypeStr(attributes.joinType),// 连接类型(LEFT/RIGHT/INNER)
					JOIN_ON_EXPRESS : [
							attributes.table.tableAsName, '.',
							attributes.name, '=',
							attributes.asName, '.',
							attributes.valueColName ].join('')
				// 例如连接表达式 TA.a= TB.a and TA.b=TB.c
				};
				DEMENSIONS.push(demension);
			}
			if (attributes.colType == biAdhocNs.COLTYPE_CODE
					&& this.isCodeRelaTable(right)
					&& item.opChar.indexOf('EXISTS') == -1) {
				demension = {
					SERIAL_ID : serial,
					SOURCE_DEST_FILED_REL : [ {
						SOURCE_FIELD_NAME : attributes.name,// 关联源表字段
						SOURCE_TABLE_NAME : attributes.table.tableName,// 关联源表名称
						SOURCE_TABLE_AS_NAME : attributes.table.tableAsName,// 关联源表别名
						DEST_FIELD_NAME : 'USR_NBR',// 目标字段名称
						DEST_TABLE_NAME : right,// 目标表名称
						DEST_TABLE_AS_NAME : [ 'tmp_', serial ]
								.join('')
					// 目标表别名
					} ],
					JOIN_TABLE_NAME : right,
					JOIN_TABLE_ALIAS : [ 'tmp_', serial ]
							.join(''),
					JOIN_TYPE : 'RIGHT',// 连接类型(LEFT/RIGHT/INNER)
					JOIN_ON_EXPRESS : [
							attributes.table.tableAsName, '.',
							attributes.name, '=',
							[ 'tmp_', serial ].join(''), '.',
							'USR_NBR' ].join('')
				// 例如连接表达式 TA.a= TB.a and TA.b=TB.c
				};
				DEMENSIONS.push(demension);
			}
		}
		return DEMENSIONS;
	},

	/**
	 * 选择操作符选择时的触发函数
	 * 
	 * @param option
	 *            操作符对象
	 */
	selectedOK : function(option) { // 操作符选择的时候
		biAdhocNs.MultSelect.clickSelect('multselect', option);
		var tip = Ext.getCmp('show-use-input');
		var win = Ext.getCmp('info-window');
		var value = option.attributes.value.value;
		this.oprationChar = value; // 保存当前选择的操作符
		var tipedit = Ext.getCmp('condition-edit'); // 获取展示tooltip对象
		var btnedit = Ext.getCmp(tipedit.parentID);
		var tipeditFlag = btnedit.attributes.colType;
		// if(Ext.getDom('fset-right-content-box').innerText !=
		// ''){
		// return;
		// }
		Ext.getDom('fset-right-content-box').innerHTML = '';
		if (value.indexOf('LIKE') != -1
				|| value.indexOf('BETWEEN') != -1) {
			var tag = ((value.indexOf('LIKE') != -1) ? this
					.makeLikeTag() : this.makeBetweenTag());
			try {
				tip.body.dom.innerHTML = tag;
			} catch (e) {
				tip.html = tag;
			}
			tip.initTarget(option.id);
			tip.show();
			// 设置输入框的当前焦点focus
			value.indexOf('LIKE') != -1 ? Ext.getDom('side2')
					.focus() : Ext.getDom('side1').focus();
			// win.hide(); //隐藏维选择框
			// Ext.getCmp('show-more-operation-select').hide();//隐藏更多操作符选择框
			/***************************************************
			 * //} else if (value.indexOf('IN') != -1) { //var
			 * btnId = this.currentSplitButtonID; //var btn =
			 * Ext.getCmp(btnId); //if (btn.attributes.colType !=
			 * biAdhocNs.COLTYPE_CODE) //
			 * this.makeDataGridPanelByShow(btn.attributes,
			 * 'IN', 'right-fieldset'); //else // win.hide();
			 * //tip.hide(); //} else if (value == '=') { //var
			 * id = this.currentSplitButtonID; //var btn =
			 * Ext.getCmp(id);
			 * //this.makeDataGridPanelByShow(btn.attributes,
			 * '=', 'right-fieldset'); //tip.hide();
			 */
		} else if (value.indexOf('AREA') != -1) {
			var tag = this.makeAreaTag()// ((value.indexOf('LIKE')
										// != -1) ?
										// this.makeLikeTag() :
										// this.makeBetweenTag());
			try {
				tip.body.dom.innerHTML = tag;
			} catch (e) {
				tip.html = tag;
			}
			tip.initTarget(option.id);
			tip.show();
			// 设置输入框的当前焦点focus
			Ext.getDom('side1').focus();
			// value.indexOf('AREA') != -1 ?
			// Ext.getDom('side2').focus() :
			// Ext.getDom('side1').focus();
			win.hide(); // 隐藏维选择框
			// Ext.getCmp('show-more-operation-select').hide();//隐藏更多操作符选择框
		} else if (value.indexOf('IN') != -1) { // 选择操作符为IN 或者为
												// NOT IN 时
												// 判断是否有左右括号
			var cbright = Ext.getDom('fset-right-content-box'); // 获取右编辑框对象
			var righttext = cbright.innerText.trim();
			var textLen = righttext.length;
			if (textLen > 0
					&& (righttext.substring(0, 1) != '(' || righttext
							.substring(textLen - 1) != ')')) {
				cbright.innerHTML = [ '(', cbright.innerHTML,
						')' ].join('');
			}
			cbright.focus(); // 光标定位到右项
			tip.hide(); // 隐藏between或like
			// Ext.getCmp('show-more-operation-select').hide();//隐藏更多操作符选择框
			// win.hide(); //隐藏维选择框
		} else if (value.indexOf(' IS ') != -1) { // 选择操作符为IN
													// 或者为 NOT
													// IN 时
													// 判断是否有左右括号
			var cbright = Ext.getDom('fset-right-content-box'); // 获取右编辑框对象
			cbright.innerText = 'NULL';
			cbright.focus(); // 光标定位到右项
			tip.hide(); // 隐藏between或like
			// Ext.getCmp('show-more-operation-select').hide();//隐藏更多操作符选择框
			// win.hide(); //隐藏维选择框
		} else if (option.id == 'condition-more-op') { // 更多
			// var moreOpTip =
			// Ext.getCmp('show-more-operation-select');
			moreOpTip.initTarget(option.id);
			moreOpTip.show();
			tip.hide(); // 隐藏between或like
			win.hide(); // 隐藏维选择框
		} else {
			Ext.getDom('fset-right-content-box').focus(); // 光标定位到右项
			tip.hide(); // 隐藏between或like
			if (tipeditFlag == 3 || tipeditFlag == 4) {
				Ext.getCmp('datefieldId').show();
			} else {
				Ext.getCmp('datefieldId').hide();
			}
			// Ext.getCmp('show-more-operation-select').hide();//隐藏更多操作符选择框
			// win.hide(); //隐藏维选择框
		}
	},

	/**
	 * 更多操作符选择的触发函数
	 * 
	 * @param option
	 *            操作符对象
	 */
	selectedMoreOpOK : function(option) { // 从更多操作符选择的时候
		biAdhocNs.MultSelect.clickSelect('more-op-multselect',
				option);
		var tip = Ext.getCmp('show-use-input');
		var win = Ext.getCmp('info-window');
		var value = option.value;
		this.oprationChar = value; // 保存当前选择的操作符

		var chooseInMore = Ext.getDom('choose-in-more-op');
		chooseInMore.value = value;
		chooseInMore.cells[0].innerText = option.cells[0].innerText;
		biAdhocNs.MultSelect.clickSelect('multselect',
				chooseInMore); // 设置更多操作符中选择的操作符
								// 在正常操作符fieldset中为 选择的样式

		if (value.indexOf('LIKE') != -1
				|| value.indexOf('BETWEEN') != -1) {
			var tag = ((value.indexOf('LIKE') != -1) ? this
					.makeLikeTag() : this.makeBetweenTag());
			try {
				tip.body.dom.innerHTML = tag;
			} catch (e) {
				tip.html = tag;
			}
			tip.initTarget(chooseInMore.id);
			tip.show();
			// 设置输入框的当前焦点focus
			value.indexOf('LIKE') != -1 ? Ext.getDom('side2')
					.focus() : Ext.getDom('side1').focus();
			win.hide(); // 隐藏维选择框
			// Ext.getCmp('show-more-operation-select').hide();//隐藏更多操作符选择框
		} else if (value.indexOf('IN') != -1) { // 选择操作符为IN 或者为
												// NOT IN 时
												// 判断是否有左右括号
			var cbright = Ext.getDom('fset-right-content-box'); // 获取右编辑框对象
			var righttext = cbright.innerText.trim();
			var textLen = righttext.length;
			if (textLen > 0
					&& (righttext.substring(0, 1) != '(' || righttext
							.substring(textLen - 1) != ')')) {
				cbright.innerHTML = [ '(', cbright.innerHTML,
						')' ].join('');
			}
			cbright.focus(); // 光标定位到右项
			tip.hide(); // 隐藏between或like
			Ext.getCmp('show-more-operation-select').hide();// 隐藏更多操作符选择框
			win.hide(); // 隐藏维选择框
		} else if (value.indexOf(' IS ') != -1) { // 选择操作符为IN
													// 或者为 NOT
													// IN 时
													// 判断是否有左右括号
			var cbright = Ext.getDom('fset-right-content-box'); // 获取右编辑框对象
			cbright.innerText = 'NULL';
			cbright.focus(); // 光标定位到右项
			tip.hide(); // 隐藏between或like
			Ext.getCmp('show-more-operation-select').hide();// 隐藏更多操作符选择框
			win.hide(); // 隐藏维选择框
		} else {
			Ext.getDom('fset-right-content-box').focus(); // 光标定位到右项
			tip.hide(); // 隐藏between或like
			Ext.getCmp('show-more-operation-select').hide();// 隐藏更多操作符选择框
			win.hide(); // 隐藏维选择框
		}
	},

	/**
	 * 根据个人视图设置是否需要显示表名
	 * 
	 * @param btn
	 *            过滤结点
	 * @param flag
	 *            操作类型
	 */
	refreshBtnTName : function(btn, flag) { // 根据个人视图设置是否需要显示表名
		if (flag == 'dropObject' || flag == 'saveDesign'
				|| btn.hiddenTableText == null
				|| btn.hiddenTableText.length == 0) { // 拖拽对象到过滤面板
														// 或者
														// 编辑保存过滤表达式
														// 或者是从旧的案例中打开
														// 时
			var text = btn.text;
			btn.showTableText = text; // 设置有表名的显示内容
			// var _hiddenTabletext = text.replaceAll(btn.atext,
			// btn.attributes.cName);
			var _hiddenTabletext = text.replaceAll(btn.text,
					btn.attributes.cName);
			for (var i = 0; btn.columnGroup != null
					&& i < btn.columnGroup.length; i++) {
				_hiddenTabletext = _hiddenTabletext
						.replaceAll(
								btn.columnGroup[i].key,
								btn.columnGroup[i].nodeAttributes.cName);
			}
			btn.hiddenTableText = _hiddenTabletext; // 设置有隐藏表名的显示内容
		}

		if (!biAdhocNs.filterflag) {// 替换所有的表名{字段名} 为 字段名 显示
			btn.setText(btn.hiddenTableText);
		} else {
			btn.setText(btn.showTableText);
		}

	},

	/**
	 * 设置过滤条件面板中的中文表名显示 接口给晓质调用
	 */
	setFilterFrameTableNameTextShow : function() { // 设置过滤条件面板中的中文表名显示
													// 接口给晓质调用
		var panel = this;
		var len = panel.items.length;
		var comp = null;
		for (var i = 0; i < len; i++) {
			comp = panel.items.items[i];
			if (comp.compType == 'label') {// 非操作符
				this.refreshBtnTName(comp);
			}
		}
	},
	synchronizationAjax : function(url, para) {
		function createXhrObject() {
			var http;
			var activeX = [ 'MSXML2.XMLHTTP.3.0',
					'MSXML2.XMLHTTP', 'Microsoft.XMLHTTP' ];
			try {
				http = new XMLHttpRequest();
			} catch (e) {
				for (var i = 0; i < activeX.length; ++i) {
					try {
						http = new ActiveXObject(activeX[i]);
						break;
					} catch (e) {
						;
					}
				}
			} finally {
				return http;
			}
		};
		var conn = createXhrObject();
		if (para != null && para != ''
				&& typeof (para) != 'undefined') {
			url = [ url, '?', para ].join('');
		}
		conn.open("GET", url, false);
		conn.send(null);
		if (conn.responseText != '') {
			var rs;
			try {
				rs = Ext.util.JSON.decode(conn.responseText);
			} catch (e) {
				return null;
			}
			return rs;
		} else {
			return null;
		}
	},
	createRandomCode : function() {
		var code = "";
		var codeLength = 30;// 验证码的长度
		var selectChar = new Array(0, 1, 2, 3, 4, 5, 6, 7, 8,
				9, 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I',
				'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R',
				'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z');// 所有候选组成验证码的字符，当然也可以用中文的
		for (var i = 0; i < codeLength; i++) {

			var charIndex = Math.floor(Math.random() * 36);
			code += selectChar[charIndex];

		}
		return code;
	}
});

/**
 * 模拟生成multselect
 */
biAdhocNs.MultSelect = function() {
	return {
		id : '', // ID
		ops : null, // 参数格式{id : '',name : '',op : '',desc : '',count : ''}
		clickFunction : '', // 传入函数
		dblclickFunction : '', // 传入双击函数
		setMultSelectID : function(id) {
			this.id = id;
		},

		/**
		 * 设置multselect的数据对象
		 * 
		 * @param ops
		 *            数据对象
		 */
		setDatas : function(ops) {
			this.ops = ops;
		},

		/**
		 * 设置multselect行的点击事件
		 * 
		 * @param fun
		 *            点击事件方法
		 */
		setCilckFunction : function(fun) {
			this.clickFunction = fun;
		},

		/**
		 * 设置multselect行的双击事件
		 * 
		 * @param dbfun
		 *            双击事件方法
		 */
		setDblClickFunction : function(dbfun) {
			this.dblclickFunction = dbfun;
		},

		/**
		 * 清空multselect
		 */
		reset : function() {
			this.id = '';
			this.ops = null;
			this.clickFunction = '';
		},

		/**
		 * multSelect box 点击事件
		 * 
		 * @param id
		 *            multSelect的table ID值
		 * @param obj
		 *            具体点击每一行
		 */
		clickSelect : function(id, obj) { // multSelect box 点击事件
			var table = Ext.getDom(id); // 具体点击每一行
			var rows = table.rows;
			var rlen = rows.length;
			for (var i = 0; i < rlen; i++) {
				if (rows[i].className == 'mouse-click') {
					rows[i].className = '';
					break;
				}
			}
			obj.className = 'mouse-click';
		},

		/**
		 * multSelect 选择事件
		 * 
		 * @param id
		 *            multSelect的table ID值
		 * @param index
		 *            某行的索引号
		 */
		clickSelectIndex : function(id, index) { // multSelect box 点击事件
			var table = Ext.getDom(id); // 具体点击每一行
			var rows = table.rows;
			var rlen = rows.length;
			for (var i = 0; i < rlen; i++) {
				if (rows[i].className == 'mouse-click') {
					rows[i].className = '';
					break;
				}
			}
			rows[index].className = 'mouse-click';
		},

		/**
		 * 设置某行是否显示
		 * 
		 * @param id
		 *            multSelect的table ID值
		 * @param index
		 *            某行的索引号
		 * @param value
		 *            是否显示的值 none 或者为空字符串
		 */
		setRowDisplay : function(id, index, value) {
			var table = Ext.getDom(id); // 具体点击每一行
			var rows = table.rows;
			var rlen = rows.length;
			if (index < rlen) {
				rows[index].style.display = value;
			}
		},

		/**
		 * 鼠标经过时事件
		 * 
		 * @param obj
		 *            鼠标经过的行对象
		 */
		overSelect : function(obj) { // 鼠标经过时事件
			if (obj.className == 'mouse-click') {
				return false;
			} else {
				obj.className = 'mouse-over';
			}
		},

		/**
		 * 鼠标离开时事件
		 * 
		 * @param obj
		 *            鼠标经过的行对象
		 */
		outSelect : function(obj) { // 鼠标离开时事件
			if (obj.className == 'mouse-click') {
				return false;
			} else {
				obj.className = '';
			}
		},

		/**
		 * 生成模拟multSelect组件
		 */
		makeMultSelect : function() { // 生成模拟multSelect组件
			if (this.ops == null)
				return;
			var len = this.ops.length;
			var str = [];
			str
					.push([
							'<TABLE id="',
							this.id,
							'" WIDTH="100%" BORDER="0" CELLPADDING="0" CELLSPACING="0" class="table-word-size">' ]
							.join(''));
			for (var i = 0; i < len; i++) {
				str
						.push([
								'<TR onmouseover="biAdhocNs.MultSelect.overSelect(this);" onmouseout="biAdhocNs.MultSelect.outSelect(this);" onclick="',
								this.clickFunction, '" ondblclick ="',
								this.dblclickFunction, '" value="',
								this.ops[i].op, '" id="', this.ops[i].id,
								'" paramcount="', this.ops[i].count,
								'" desc="', this.ops[i].desc, '"><TD>',
								this.ops[i].name, '</TD></TR>' ].join(''));
			}
			str.push('</TABLE>');
			this.reset();
			return str.join('');
		}
	};
}();

// 调用以下程序
function trim(s) {
	s = removebeforechar(s);
	s = removeafterchar(s);
	return s;
}
// 去前空格
function removebeforechar(t) {
	if (t.charCodeAt(0) == 32 || t.charCodeAt(0) == 12288) {
		t = t.slice(1, t.length);
		return removebeforechar(t);
	} else {
		return t;
	}
}
// 去后空格
function removeafterchar(t) {
	if (t.charCodeAt(t.length - 1) == 32 || t.charCodeAt(t.length - 1) == 12288) {
		t = t.slice(0, t.length - 1);
		return removeafterchar(t);
	} else {
		return t;
	}
}

Ext.reg('uc_conditionfilter', biAdhocNs.ConditionFilter);
